SpringBoot整合

约定不等于承诺〃 2022-04-25 06:10 495阅读 0赞

开发环境
开发工具：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的父工程，这是每个项目都要有的
①

  1. <!-- SpringBoot父依赖 -->
  2.     <parent>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-parent</artifactId>
  5.         <version>2.1.3.RELEASE</version>
  6.         <relativePath/>
  7.     </parent>
  8.     <!-- JAVA版本与编码 -->
  9.     <properties>
  10.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  11.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  12.         <java.version>1.8</java.version>
  13.     </properties>

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

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-web</artifactId>
  4.  </dependency>

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

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.context.annotation.ComponentScan;
  5. @SpringBootApplication
  6. @ComponentScan("com.quotation")
  7. public class QuotationApplication { 
  8.     public static void main(String[] args) { 
  9.         SpringApplication.run(QuotationApplication.class, args);
  10.     }

@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）

  1. #设置端口号和context path
  2. server:
  3.   port: 8088
  4.   servlet:
  5.     context-path: /quotation
  7. #使用thymeleaf
  8. spring:
  9.   thymeleaf:
  10.     cache: false
  11.     suffix: .html
  12.     prefix: classpath:/templates/

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

④创建Controller

  1. @RestController
  2. @RequestMapping("hello")
  3. public class HelloController { 
  5.     @RequestMapping("helloworld")
  6.     public String say(){ 
  7.         return "hello world";
  8.     }
  10.     @RequestMapping("/test")
  11.     public ModelAndView test(){ 
  12.         return new ModelAndView("index");
  13.     }
  15. }

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

  1. <!--jdbc-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-jdbc</artifactId>
  5.         </dependency>
  6.         <!--SpringBoot MyBatis启动器-->
  7.         <dependency>
  8.             <groupId>org.mybatis.spring.boot</groupId>
  9.             <artifactId>mybatis-spring-boot-starter</artifactId>
  10.             <version>1.2.2</version>
  11.         </dependency>
  12.          <!--oracle-->
  13.         <dependency>
  14.             <groupId>ojdbc</groupId>
  15.             <artifactId>ojdbc6</artifactId>
  16.             <version>11.2.0.3</version>
  17.         </dependency>
  18.      <!-- 数据库连接池 -->
  19.        <!-- <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency>-->
  20.         <dependency>
  21.             <groupId>com.alibaba</groupId>
  22.             <artifactId>druid-spring-boot-starter</artifactId>
  23.             <version>1.1.10</version>
  24.         </dependency>

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
  3. <!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
  4. <!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
  5. <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
  6. <configuration>
  7.     <contextName>logback</contextName>
  8.     <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
  9.     <property name="log.path" value="../customlogs" />
  11.     <!--输出到控制台-->
  12.     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  13.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  14.            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
  15.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  16.         </encoder>
  17.     </appender>
  19.     <!--输出到文件-->
  20.     <!-- 时间滚动输出 level为 DEBUG 日志 -->
  21.     <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  22.         <!-- 正在记录的日志文件的路径及文件名 -->
  23.         <file>${log.path}/log_debug.log</file>
  24.         <!--日志文件输出格式-->
  25.         <encoder>
  26.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  27.             <charset>UTF-8</charset> <!-- 设置字符集 -->
  28.         </encoder>
  29.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  30.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  31.             <!-- 日志归档 -->
  32.             <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  33.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  34.                 <maxFileSize>100MB</maxFileSize>
  35.             </timeBasedFileNamingAndTriggeringPolicy>
  36.             <!--日志文件保留天数-->
  37.             <maxHistory>15</maxHistory>
  38.         </rollingPolicy>
  39.         <!-- 此日志文件只记录debug级别的 -->
  40.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  41.             <level>debug</level>
  42.             <onMatch>ACCEPT</onMatch>
  43.             <onMismatch>DENY</onMismatch>
  44.         </filter>
  45.     </appender>
  47.     <!-- 时间滚动输出 level为 INFO 日志 -->
  48.     <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  49.         <!-- 正在记录的日志文件的路径及文件名 -->
  50.         <file>${log.path}/log_info.log</file>
  51.         <!--日志文件输出格式-->
  52.         <encoder>
  53.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  54.             <charset>UTF-8</charset>
  55.         </encoder>
  56.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  57.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  58.             <!-- 每天日志归档路径以及格式 -->
  59.             <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  60.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  61.                 <maxFileSize>100MB</maxFileSize>
  62.             </timeBasedFileNamingAndTriggeringPolicy>
  63.             <!--日志文件保留天数-->
  64.             <maxHistory>15</maxHistory>
  65.         </rollingPolicy>
  66.         <!-- 此日志文件只记录info级别的 -->
  67.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  68.             <level>info</level>
  69.             <onMatch>ACCEPT</onMatch>
  70.             <onMismatch>DENY</onMismatch>
  71.         </filter>
  72.     </appender>
  74.     <!-- 时间滚动输出 level为 WARN 日志 -->
  75.     <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  76.         <!-- 正在记录的日志文件的路径及文件名 -->
  77.         <file>${log.path}/log_warn.log</file>
  78.         <!--日志文件输出格式-->
  79.         <encoder>
  80.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  81.             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
  82.         </encoder>
  83.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  84.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  85.             <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  86.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  87.                 <maxFileSize>100MB</maxFileSize>
  88.             </timeBasedFileNamingAndTriggeringPolicy>
  89.             <!--日志文件保留天数-->
  90.             <maxHistory>15</maxHistory>
  91.         </rollingPolicy>
  92.         <!-- 此日志文件只记录warn级别的 -->
  93.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  94.             <level>warn</level>
  95.             <onMatch>ACCEPT</onMatch>
  96.             <onMismatch>DENY</onMismatch>
  97.         </filter>
  98.     </appender>
  101.     <!-- 时间滚动输出 level为 ERROR 日志 -->
  102.     <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  103.         <!-- 正在记录的日志文件的路径及文件名 -->
  104.         <file>${log.path}/log_error.log</file>
  105.         <!--日志文件输出格式-->
  106.         <encoder>
  107.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  108.             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
  109.         </encoder>
  110.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  111.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  112.             <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  113.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  114.                 <maxFileSize>100MB</maxFileSize>
  115.             </timeBasedFileNamingAndTriggeringPolicy>
  116.             <!--日志文件保留天数-->
  117.             <maxHistory>15</maxHistory>
  118.         </rollingPolicy>
  119.         <!-- 此日志文件只记录ERROR级别的 -->
  120.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  121.             <level>ERROR</level>
  122.             <onMatch>ACCEPT</onMatch>
  123.             <onMismatch>DENY</onMismatch>
  124.         </filter>
  125.     </appender>
  127.     <!-- <logger>用来设置某一个包或者具体的某一个类的日志打印级别、 以及指定<appender>。<logger>仅有一个name属性， 一个可选的level和一个可选的addtivity属性。 name:用来指定受此logger约束的某一个包或者具体的某一个类。 level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。 如果未设置此属性，那么当前logger将会继承上级的级别。 addtivity:是否向上级logger传递打印信息。默认是true。 -->
  128.     <!--<logger name="org.springframework.web" level="info"/>-->
  129.     <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
  130.     <!-- 使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作： 第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息 第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别： -->
  133.     <!-- root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性 level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 不能设置为INHERITED或者同义词NULL。默认是DEBUG 可以包含零个或多个元素，标识这个appender将会添加到这个logger。 -->
  135.     <root level="info">
  136.         <appender-ref ref="CONSOLE" />
  137.         <appender-ref ref="DEBUG_FILE" />
  138.         <appender-ref ref="INFO_FILE" />
  139.         <appender-ref ref="WARN_FILE" />
  140.         <appender-ref ref="ERROR_FILE" />
  141.     </root>
  142. </configuration>

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

  1. #打印SQL，把level下的路径换成你对应mapper包路径
  2. logging:
  3.   level:
  4.     com:
  5.       vtech:
  6.         quotation:
  7.           mapper: debug

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

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

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

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

  1. import com.alibaba.druid.pool.DruidDataSource;
  2. import com.alibaba.druid.support.http.StatViewServlet;
  3. import com.alibaba.druid.support.http.WebStatFilter;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  7. import org.springframework.boot.web.servlet.ServletRegistrationBean;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.context.annotation.Primary;
  11. import javax.sql.DataSource;
  12. import java.util.HashMap;
  13. import java.util.Map;
  15. @Configuration
  16. @Slf4j
  17. public class DruidConfig { 
  19.     @Value("${spring.datasource.druid.url}")
  20.     private String dbUrl;
  22.     @Value("${spring.datasource.druid.username}")
  23.     private String username;
  25.     @Value("${spring.datasource.druid.password}")
  26.     private String password;
  28.     @Value("${spring.datasource.druid.driver-class-name}")
  29.     private String driverClassName;
  31.     @Value("${spring.datasource.druid.initial-size}")
  32.     private int initialSize;
  34.     @Value("${spring.datasource.druid.min-idle}")
  35.     private int minIdle;
  37.     @Value("${spring.datasource.druid.max-active}")
  38.     private int maxActive;
  40.     @Value("${spring.datasource.druid.max-wait}")
  41.     private int maxWait;
  43.     @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
  44.     private int timeBetweenEvictionRunsMillis;
  46.     @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
  47.     private int minEvictableIdleTimeMillis;
  49.     @Value("${spring.datasource.druid.validation-query}")
  50.     private String validationQuery;
  52.     @Value("${spring.datasource.druid.test-while-idle}")
  53.     private boolean testWhileIdle;
  55.     @Value("${spring.datasource.druid.test-on-borrow}")
  56.     private boolean testOnBorrow;
  58.     @Value("${spring.datasource.druid.test-on-return}")
  59.     private boolean testOnReturn;
  61.     @Value("${spring.datasource.druid.pool-prepared-statements}")
  62.     private boolean poolPreparedStatements;
  64.     @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
  65.     private int maxPoolPreparedStatementPerConnectionSize;
  67.     @Value("${spring.datasource.druid.filters}")
  68.     private String filters;
  70.     @Value("{spring.datasource.druid.connection-properties}")
  71.     private String connectionProperties;
  73.     @Bean     //声明其为Bean实例
  74.     @Primary  //在同样的DataSource中，首先使用被标注的DataSource
  75.     public DataSource dataSource() { 
  76.         DruidDataSource datasource = new DruidDataSource();
  77.         datasource.setUrl(dbUrl);
  78.         datasource.setUsername(username);
  79.         datasource.setPassword(password);
  80.         datasource.setDriverClassName(driverClassName);
  81.         //configuration
  82.         datasource.setInitialSize(initialSize);
  83.         datasource.setMinIdle(minIdle);
  84.         datasource.setMaxActive(maxActive);
  85.         datasource.setMaxWait(maxWait);
  86.         datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  87.         datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  88.         datasource.setValidationQuery(validationQuery);
  89.         datasource.setTestWhileIdle(testWhileIdle);
  90.         datasource.setTestOnBorrow(testOnBorrow);
  91.         datasource.setTestOnReturn(testOnReturn);
  92.         datasource.setPoolPreparedStatements(poolPreparedStatements);
  93.         datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
  94.         try { 
  95.             datasource.setFilters(filters);
  96.         } catch (Exception e) { 
  97.             log.error("druid configuration initialization filter", e);
  98.         }
  99.         datasource.setConnectionProperties(connectionProperties);
  101.         return datasource;
  102.     }
  104.     @Bean
  105.     public ServletRegistrationBean druidServlet() { 
  106.         //logger.info("init Druid Servlet Configuration ");
  107.         ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();
  108.         servletRegistrationBean.setServlet(new StatViewServlet());
  109.         servletRegistrationBean.addUrlMappings("/druid/*");
  110.         Map<String, String> initParameters = new HashMap<>();
  111.         initParameters.put("loginUsername", "admin");// 用户名
  112.         initParameters.put("loginPassword", "admin");// 密码
  113.         //initParameters.put("resetEnable", "");// 禁用HTML页面上的“Reset All”功能
  114.         initParameters.put("allow", ""); // IP白名单 (没有配置或者为空，则允许所有访问)
  115.         //initParameters.put("deny", "192.168.20.38");// IP黑名单 (存在共同时，deny优先于allow)
  116.         servletRegistrationBean.setInitParameters(initParameters);
  117.         return servletRegistrationBean;
  118.     }
  121.     @Bean
  122.     public FilterRegistrationBean druidWebStatViewFilter() { 
  123.         FilterRegistrationBean registrationBean = new FilterRegistrationBean(new WebStatFilter());
  124.         registrationBean.addInitParameter("urlPatterns", "/*");
  125.         registrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*");
  126.         return registrationBean;
  127.     }
  129. }

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

创建Users.java

  1. @Data
  2. public class Users { 
  3.     private BigDecimal userId;
  4.     private String userName;
  5.     private String password;
  6.     }

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

  1. @Mapper
  2. @Repository
  3. public interface UsersMapper { 
  4.     List<Users> findAll();
  5. }

创建UsersMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.vtech.quotation.mapper.UsersMapper">
  4.     <resultMap id="BaseResultMap" type="com.vtech.quotation.pojo.Users">
  5.         <id column="USER_ID" jdbcType="DECIMAL" property="userId"/>
  6.         <result column="USER_NAME" jdbcType="VARCHAR" property="userName"/>
  7.         <result column="PASSWORD" jdbcType="VARCHAR" property="password"/>
  8.     </resultMap>
  9.     <sql id="result_Internal_User">
  10.         USER_ID, USER_NAME, FIRST_NAME, LAST_NAME, STATUS, EMAIL_ADDRESS, ISMANAGER,
  11.         BU, CREATE_BY, CREATION_DATE, MODIFIED_BY,
  12.         MODIFIED_DATE
  13.     </sql>
  15.     <select id="findAll" resultMap="BaseResultMap">
  16.         select
  17.         <include refid="result_Internal_User"/>
  18.         from USERS
  19.     </select>
  20. </mapper>

②application.yml添加mybatis配置

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

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

  1. @SpringBootApplication
  2. @MapperScan(value = "com.vtech.quotation.mapper")
  3. @ComponentScan(basePackages = "com.vtech")
  4. public class QuotationApplication { 
  5.     public static void main(String[] args) { 
  6.         SpringApplication.run(QuotationApplication.class, args);
  7.     }
  9. }

④测试HelloController .java

  1. @RestController
  2. @RequestMapping("hello")
  3. @Slf4j
  4. public class HelloController { 
  5.     @Autowired
  6.     UsersMapper usersMapper；
  8.     @RequestMapping("findAll")
  9.     public JsonResult findall(){ 
  10.         return new JsonResult(usersMapper.findAll());
  11.     }
  13. }

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

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，495人围观）

还没有评论，来说两句吧...

相关阅读