SpringBoot（二）web开发_thymeleaf的使用_mvc扩展_error页_拦截器_mybatis-druid整合

早餐有胃口吗

已于 2022-09-18 21:31:56 修改

阅读量707

点赞数 1

分类专栏： SpringBoot 文章标签： mybatis spring boot

于 2022-09-18 21:28:45 首次发布

本文链接：https://blog.csdn.net/qq_53261858/article/details/126923340

版权

SpringBoot 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

静态资源导入

默认位置

静态资源可以放在：

resource文件夹下的static下（/static/**）
resource文件夹下的public下（/public/**）
resource文件夹下的resources下（/resources/**）
resource文件夹下（/**）

访问路径：localhost:8080/

也可以放在webjars下：

WebJars是将web前端资源（js，css等）打成jar包文件，然后借助Maven工具，以jar包形式对web前端资源进行统一依赖管理，保证这些Web资源版本唯一性。WebJars的jar包部署在Maven中央仓库上。

去webjars官网找需要下载相关依赖，如jquery
添加该依赖
找到该依赖的Maven包下的MATE_INF/resources/webjars下的jquery

访问路径：localhost:8080/webjars/jquery/3.4.1/jquery.js

手动修改静态资源访问路径

spring:
  mvc:
    static-path-pattern: /hello/**

访问路径：localhost:8080/hello/1.js

我们也可以自己通过配置文件来指定一下，哪些文件夹是需要我们放静态资源文件的，在application.properties中配置：

spring.resources.static-locations=classpath:/coding/,classpath:/jia/

首页及项目图标设置

首页

全局搜索ctrl+n，WebMvcAutoConfiguration这个文件
ctrl+f搜索welcomepage或者index就可以找到相关的首页信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JcSeNQID-1663507052210)(springboot笔记/image-20220908160754687.png)]

可将index.html放在静态资源目录下，如static目录下
localhost:8080 直接访问首页index.html

图标

新版本的springboot中WebMVCAutoConfiguration中已经把favicon删掉了

若需使用图标定制，可以回退到2.1.7版本之前看看

进入到WebMVCAutoConfiguration中看看是否有favicon相关信息，若有就可使用

将图片命名为favicon.ico
将favicon.ico图片放在static目录下，或剖析源码找到放的位置，一般放在静态资源目录下
#关闭默认图标
spring.mvc.favicon.enabled=false
localhost:8080 访问

模板引擎thymeleaf

模板引擎概念

前端交给我们的页面，是html页面。如果是我们以前开发，我们需要把他们转成jsp页面，jsp好处就是当我们查出一些数据转发到JSP页面以后，我们可以用jsp轻松实现数据的显示，及交互等。jsp支持非常强大的功能，包括能写Java代码，但是呢，我们现在的这种情况

SpringBoot这个项目首先是以jar的方式，不是war，像第二，我们用的还是嵌入式的Tomcat，所以呢，他现在默认是不支持jsp的。

那不支持jsp，如果我们直接用纯静态页面的方式，那给我们开发会带来非常大的麻烦,
SpringBoot推荐使用模板引擎。

jsp也是一个模板引擎，还有以用的比较多的freemarker，包括SpringBoot给我们推荐的Thymeleaf，他们的思想都是一样的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C0fY5zTz-1663507052212)(springboot笔记/image-20220908162552788.png)]

thymeleaf语法

在HTML文件里加上命名空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

然后再编写代码就会有提示信息。

1、我们可以使用任意的 th:attr 来替换Html中原生属性的值！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mp97R1sa-1663507052213)(springboot笔记/640.jpeg)]

2、我们能写哪些表达式呢？

Simple expressions:（表达式语法）
Variable Expressions: ${...}：获取变量值；OGNL；
    1）、获取对象的属性、调用方法
    2）、使用内置的基本对象：#18
         #ctx : the context object.
         #vars: the context variables.
         #locale : the context locale.
         #request : (only in Web Contexts) the HttpServletRequest object.
         #response : (only in Web Contexts) the HttpServletResponse object.
         #session : (only in Web Contexts) the HttpSession object.
         #servletContext : (only in Web Contexts) the ServletContext object.

    3）、内置的一些工具对象：
　　　　　　#execInfo : information about the template being processed.
　　　　　　#uris : methods for escaping parts of URLs/URIs
　　　　　　#conversions : methods for executing the configured conversion service (if any).
　　　　　　#dates : methods for java.util.Date objects: formatting, component extraction, etc.
　　　　　　#calendars : analogous to #dates , but for java.util.Calendar objects.
　　　　　　#numbers : methods for formatting numeric objects.
　　　　　　#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
　　　　　　#objects : methods for objects in general.
　　　　　　#bools : methods for boolean evaluation.
　　　　　　#arrays : methods for arrays.
　　　　　　#lists : methods for lists.
　　　　　　#sets : methods for sets.
　　　　　　#maps : methods for maps.
　　　　　　#aggregates : methods for creating aggregates on arrays or collections.
==================================================================================

  Selection Variable Expressions: *{...}：选择表达式：和${}在功能上是一样；
  Message Expressions: #{...}：获取国际化内容
  Link URL Expressions: @{...}：定义URL；
  Fragment Expressions: ~{...}：片段引用表达式

Literals（字面量）
      Text literals: 'one text' , 'Another one!' ,…
      Number literals: 0 , 34 , 3.0 , 12.3 ,…
      Boolean literals: true , false
      Null literal: null
      Literal tokens: one , sometext , main ,…
      
Text operations:（文本操作）
    String concatenation: +
    Literal substitutions: |The name is ${name}|
    
Arithmetic operations:（数学运算）
    Binary operators: + , - , * , / , %
    Minus sign (unary operator): -
    
Boolean operations:（布尔运算）
    Binary operators: and , or
    Boolean negation (unary operator): ! , not
    
Comparisons and equality:（比较运算）
    Comparators: > , < , >= , <= ( gt , lt , ge , le )
    Equality operators: == , != ( eq , ne )
    
Conditional operators:条件运算（三元运算符）
    If-then: (if) ? (then)
    If-then-else: (if) ? (then) : (else)
    Default: (value) ?: (defaultvalue)
    
Special tokens:
    No-Operation: _

thymeleaf的使用

th:text、th:utext、th:each、th:if

在springboot 官方文档找到start启动器，再找到thymeleaf的启动器pom依赖

<!--    添加thymeleaf依賴-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-java8time</artifactId>
        </dependency>

搜素thymeleafProperties文件分析得到模板引擎存放页面的位置（templates下以html后缀）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v8W8Q70P-1663507052215)(springboot笔记/image-20220908165357641.png)]

在该位置创建hello.html页，通过controller跳转到该页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>thymeleaf hello！</h1>
<h2 th:text="${msg}"></h2>
<h2 th:utext="${msg}"></h2>
<li th:each="user:${users}" th:text="${user}"></li>
<li th:each="user:${users}" >[[${user}]]</li>
<h2 th:if="${not #strings.isEmpty(msg)}" th:text="${msg}"></h2>
<input type="radio" th:checked="${employee.getGender==0}" name="gender" value="0">
								
</body>
</html>

@Controller
@RequestMapping("/hello")
public class HelloController {
    @RequestMapping("/tohello")
    public String toHello(Model model){
        model.addAttribute("msg","这是一个thymeleaf测试");
        model.addAttribute("users", Arrays.asList("早餐","有胃","口吗"));
        return "hello";
    }
}

th:fragment

将公共部分抽取出来：

th:fragment=“名字”

使用改fragment（th:replace或者th:insert，后者会插入多出一个div）：

<div th:replace="~{/commons/common.html::upbar}"></div>
//<div th:replace="~{templates下开始的路径::fragment名字}"></div>

fragment传递参数

<div th:replace="~{/commons/common.html::sidebar(active='list')}"></div>

参数传递使用：

<a th:class="${active=='main'? 'nav-link active':'nav-link'}" th:href="@{/main.html}">

#dates.Format日期转换

<td th:text="${#dates.format(emp.getBirth,'yyyy-MM-dd HH:mm:ss')}"></td>

#strings.isEmpty字符串不为空时显示

<h2 th:if="${not #strings.isEmpty(msg)}" th:text="${msg}"></h2>

MVC自动配置及扩展

在进行项目编写前，还需要知道SpringBoot对我们的SpringMVC还做了哪些配置，包括如何扩展，如何定制。

只有把这些都搞清楚了，我们在之后使用才会更加得心应手。途径一：源码分析，途径二：官方文档！

地址：https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/htmlsingle/#boot-features-spring-mvc-auto-configuration

官网解说：

Spring MVC Auto-configuration
// Spring Boot为Spring MVC提供了自动配置，它可以很好地与大多数应用程序一起工作。
Spring Boot provides auto-configuration for Spring MVC that works well with most applications.
// 自动配置在Spring默认设置的基础上添加了以下功能：
The auto-configuration adds the following features on top of Spring’s defaults:
// 包含视图解析器
Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
// 支持静态资源文件夹的路径，以及webjars
Support for serving static resources, including support for WebJars 
// 自动注册了Converter：
// 转换器，这就是我们网页提交数据到后台自动封装成为对象的东西，比如把"1"字符串自动转换为int类型
// Formatter：【格式化器，比如页面给我们了一个2019-8-10，它会给我们自动格式化为Date对象】
Automatic registration of Converter, GenericConverter, and Formatter beans.
// HttpMessageConverters
// SpringMVC用来转换Http请求和响应的的，比如我们要把一个User对象转换为JSON字符串，可以去看官网文档解释；
Support for HttpMessageConverters (covered later in this document).
// 定义错误代码生成规则的
Automatic registration of MessageCodesResolver (covered later in this document).
// 首页定制
Static index.html support.
// 图标定制
Custom Favicon support (covered later in this document).
// 初始化数据绑定器：帮我们把请求数据绑定到JavaBean中！
Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).

/*
如果您希望保留Spring Boot MVC功能，并且希望添加其他MVC配置（拦截器、格式化程序、视图控制器和其他功能），则可以添加自己
的@configuration类，类型为webmvcconfiguer，但不添加@EnableWebMvc。如果希望提供
RequestMappingHandlerMapping、RequestMappingHandlerAdapter或ExceptionHandlerExceptionResolver的自定义
实例，则可以声明WebMVCregistrationAdapter实例来提供此类组件。
*/
If you want to keep Spring Boot MVC features and you want to add additional MVC configuration 
(interceptors, formatters, view controllers, and other features), you can add your own 
@Configuration class of type WebMvcConfigurer but without @EnableWebMvc. If you wish to provide 
custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or 
ExceptionHandlerExceptionResolver, you can declare a WebMvcRegistrationsAdapter instance to provide such components.

// 如果您想完全控制Spring MVC，可以添加自己的@Configuration，并用@EnableWebMvc进行注释。
If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

ContentNegotiatingViewResolver 内容协商视图解析器

自动配置了ViewResolver，就是我们之前学习的SpringMVC的视图解析器；

即根据方法的返回值取得视图对象（View），然后由视图对象决定如何渲染（转发，重定向）。

我们去看看这里的源码：我们找到 WebMvcAutoConfiguration ，然后搜索ContentNegotiatingViewResolver。

ContentNegotiatingViewResolver 这个视图解析器就是用来组合所有的视图解析器的

它是在容器中去找视图解析器，我们可以自己给容器中去添加一个视图解析器；这个类就会帮我们自动的将它组合进来；

写一个视图解析器；

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.Locale;

//扩展SpringMVC
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    //把自己定义的视图解析器放到bean中
    @Bean
    public  ViewResolver myViewResolver(){
        return new myViewResolver();
    }

    //定义了一个自己的视图解析器
    private static class myViewResolver implements ViewResolver{
        @Override
        public View resolveViewName(String viewName, Locale locale) throws Exception {
            return null;
        }
    }
}

2、怎么看我们自己写的视图解析器有没有起作用呢？

我们给 DispatcherServlet 中的 doDispatch方法加个断点进行调试一下，因为所有的请求都会走到这个方法中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OsHDxFaZ-1663507052216)(springboot笔记/640.png)]

3、我们启动我们的项目，然后随便访问一个页面，看一下Debug信息；

找到this

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k1Meggaj-1663507052218)(springboot笔记/640-16630531850781.png)]

找到视图解析器，我们看到我们自己定义的就在这里了；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y774ZiiC-1663507052219)(springboot笔记/640-16630531850782.png)]

所以说，我们如果想要使用自己定制化的东西，我们只需要给容器中添加这个组件就好了，剩下的事情SpringBoot就会帮我们做

日期转换器和格式化器

找到格式化转换器：

可以看到在我们的Properties文件中，我们可以进行自动配置它！

如果配置了自己的格式化方式，就会注册到Bean中生效，我们可以在配置文件中配置日期格式化的规则：

#修改日期格式默认的格式就不能用了（默认2022/09/14）
spring.mvc.format.date=yyyy-MM-dd

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lUJNwvB6-1663507052220)(springboot笔记/640-16630531850783.png)]

扩展SpringMVC

这么多的自动配置，原理都是一样的，通过这个WebMVC的自动配置原理分析，我们要学会一种学习方式，通过源码探究，得出结论；这个结论一定是属于自己的，而且一通百通。

SpringBoot的底层，大量用到了这些设计细节思想，所以，没事需要多阅读源码！得出结论；

SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（如果用户自己配置@bean），如果有就用用户配置的，如果没有就用自动配置的；

如果有些组件可以存在多个，比如我们的视图解析器，就将用户配置的和自己默认的组合起来！

扩展使用SpringMVC 官方文档如下：

If you want to keep Spring Boot MVC features and you want to add additional MVC configuration (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, you can declare a WebMvcRegistrationsAdapter instance to provide such components.

我们要做的就是编写一个@Configuration注解类，并且类型要为WebMvcConfigurer，还不能标注@EnableWebMvc注解

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.Locale;
//扩展SpringMVC
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/index.html").setViewName("index");
    }
}

所有的WebMvcConfiguration都会被作用，不止Spring自己的配置类，我们自己的配置类当然也会被调用；

全面接管SpringMVC

官方文档：

If you want to take complete control of Spring MVCyou can add your own @Configuration annotated with @EnableWebMvc.

全面接管即：SpringBoot对SpringMVC的自动配置不需要了，所有都是我们自己去配置！

只需在我们的配置类中要加一个@EnableWebMvc。

我们看下如果我们全面接管了SpringMVC了，我们之前SpringBoot给我们配置的静态资源映射一定会无效，我们可以去测试一下；

不加注解之前，访问首页：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lefROptL-1663507052221)(springboot笔记/640-16630531850795.png)]

给配置类加上注解：@EnableWebMvc

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OZVhLIfY-1663507052222)(springboot笔记/640-16630531850796.png)]

我们发现所有的SpringMVC自动配置都失效了！回归到了最初的样子；

当然，我们开发中，不推荐使用全面接管SpringMVC

思考问题？为什么加了一个注解，自动配置就失效了！我们看下源码：

1、这里发现它是导入了一个类，我们可以继续进去看

@Import({DelegatingWebMvcConfiguration.class})public @interface EnableWebMvc {}

2、它继承了一个父类 WebMvcConfigurationSupport

public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {  // ......}

3、我们来回顾一下Webmvc自动配置类

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
// 这个注解的意思就是：容器中没有这个组件的时候，这个自动配置类才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
    ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
    
}

总结一句话：@EnableWebMvc将WebMvcConfigurationSupport组件导入进来了；

而导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能

在SpringBoot中会有非常多的扩展配置，只要看见了这个，我们就应该多留心注意

拦截器

创建interceptor包，在该包下创建LoginHandlerInterceptor类实现拦截器接口

添加登录拦截器，实现HandlerInterceptor接口

true 放行，false 不放行

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginHandlerInterceptor implements HandlerInterceptor {

    //true 放行 false 不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object loginUser = request.getSession().getAttribute("loginUser");
        if(loginUser==null){
            request.setAttribute("msg","没有权限，请先登录");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{
            return true;
        }
    }
}

注册该拦截器到mvc配置中

注意：静态资源、登录请求不要被拦截

import com.jia.interceptor.LoginHandlerInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor()).
                addPathPatterns("/**").
                excludePathPatterns("/","/index.html","/login","/asserts/**");
    }
}

404页面及注销

404

在template下创建error文件夹
在error文件夹下创建404.html页面或者500.html页面
localhost:8080/index.html2333333，跳到404页面

注销

@GetMapping("logout")
    public String logout(HttpSession session){
        session.invalidate();
        return "redirect:/index.html";
    }

整合JDBC

SpringData 简介

对于数据访问层，无论是 SQL(关系型数据库) 还是 NOSQL(非关系型数据库)，Spring Boot 底层都是采用 Spring Data 的方式进行统一处理。

Spring Boot 底层都是采用 Spring Data 的方式进行统一处理各种数据库，Spring Data 也是 Spring 中与 Spring Boot、Spring Cloud 等齐名的知名项目。

Sping Data 官网：https://spring.io/projects/spring-data

数据库相关的启动器：可以参考官方文档：

https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/htmlsingle/#using-boot-starter

jdbc整合

添加 JDBC依赖和mysql依赖

<!--        JDBC-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
<!--        mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

在yaml配置文件中配置数据库连接属性

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/yeujuan?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    username: 'root'
    password: 'root'
    driver-class-name: com.mysql.cj.jdbc.Driver

springboot测试文件中测试输出数据源和连接对象

@SpringBootTest
class EmployeeSystemApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }
}

输出结果：

数据源：class com.zaxxer.hikari.HikariDataSource
连接对象：HikariProxyConnection@1315188449 wrapping com.mysql.cj.jdbc.ConnectionImpl@29ebbdf4

以前的版本，如 Spring Boot 1.5 默认使用 org.apache.tomcat.jdbc.pool.DataSource 作为数据源

HikariDataSource 号称 Java WEB 当前速度最快的数据源，相比于传统的 C3P0 、DBCP、Tomcat jdbc 等连接池更加优秀；

可以使用 spring.datasource.type 指定自定义的数据源类型，值为要使用的连接池实现的完全限定名。

JdbcTemplate

有了数据源(com.zaxxer.hikari.HikariDataSource)，然后可以拿到数据库连接(java.sql.Connection)，有了连接，就可以使用原生的 JDBC 语句来操作数据库；
即使不使用第三方第数据库操作框架，如 MyBatis等，Spring 本身也对原生的JDBC 做了轻量级的封装，即JdbcTemplate。
数据库操作的所有 CRUD 方法都在 JdbcTemplate 中。
Spring Boot 不仅提供了默认的数据源，同时默认已经配置好了 JdbcTemplate 放在了容器中，程序员只需自己注入即可使用
JdbcTemplate 的自动配置是依赖 org.springframework.boot.autoconfigure.jdbc 包下的 JdbcTemplateConfiguration 类

JdbcTemplate主要提供以下几类方法：

execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；

常见的DDL语句：

创建数据库CREATE DATABASE、创建数据库表格CREATE TABLE、修改数据库表格ALTER TABLE、删除数据库表格DROP TABLE、创建查询命令CREATE VIEW、修改查询命令ALTER VIEW、删除查询命令DROP VIEW、删除数据表内容TRUNCATE TABLE。

update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
query方法及queryForXXX方法：用于执行查询相关语句；
call方法：用于执行存储过程、函数相关语句。
编写controller测试类进行crud

JdbcTemplate 中会自己注入数据源，用于简化 JDBC操作 ,还能避免一些常见的错误,使用起来也不用自己关闭数据库连接

Controller测试类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
public class JDBCController {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @RequestMapping("/queryAll")
    public List<Map<String, Object>> queryUserList(){
        String sql="select * from user";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }

    @RequestMapping("/addUser")
    public String addUser(){
        String sql="insert into user values(null,'ddd','2121',0)";
        int update = jdbcTemplate.update(sql);
        if(update==1){
            return "add-ok";
        }else{
            return "error";
        }
    }

    @RequestMapping("/delete")
    public String deleteUser(Integer id){
        String sql="delete from user where id = ?";
        int update = jdbcTemplate.update(sql,id);
        if(update==1){
            return "delete-ok";
        }else{
            return "error";
        }
    }

    @RequestMapping("/updateUser")
    public String updateUser(String password,Integer role,Integer id){
        String sql="update user set `password`=?,`role`=? where id=?";
        Object[] objects=new Object[3];
        objects[0]=password;
        if(role==null){
            objects[1]=5;
        }else{
            objects[1]=role;
        }
        objects[2]=id;
        int update = jdbcTemplate.update(sql,objects);
        if(update==1){
            return "update-ok";
        }else{
            return "error";
        }
    }
}

关于database爆红

添加其他连接池的依赖(比如druid) ，刷新一下maven，红线消失

<!-- Druid连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

虽然使用默认HikariDataSource数据库连接池时爆红，但不影响后面的curd等操作

整合Druid

Druid介绍

Java程序很大一部分要操作数据库，为了提高性能操作数据库的时候，又不得不使用数据库连接池。

Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。

Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。

Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。

Spring Boot 2.0 以上默认使用 Hikari 数据源，可以说 Hikari 与 Driud 都是当前 Java Web 上最优秀的数据源

Github地址：https://github.com/alibaba/druid/

com.alibaba.druid.pool.DruidDataSource 基本配置参数如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v3dx33D9-1663507052223)(springboot笔记/640.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XkREuwJ2-1663507052224)(springboot笔记/640-16634817543363.jpeg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UCk8KZrg-1663507052225)(springboot笔记/640-16634817948038.jpeg)]

配置Druid数据源

添加Druid数据源依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.6</version>
</dependency>

配置文件中设置datasource的type类型

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/yeujuan?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    username: 'root'
    password: 'root'
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

测试输出数据源

@SpringBootTest
class EmployeeSystemApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }
}

输出结果：

数据源：class com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceWrapper
连接对象：com.mysql.cj.jdbc.ConnectionImpl@f9f3928

切换成功，就可以设置数据源连接初始化大小、最大连接数、等待时间、最小连接数等设置项。可以查看源码

spring:
  datasource:
    username: root
    password: 123456
    #?serverTimezone=UTC解决时区的报错
    url: jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    #Spring Boot 默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    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，stat:监控统计、log4j：日志记录、wall：防御sql注入
    #如果允许时报错  java.lang.ClassNotFoundException: org.apache.log4j.Priority
    #则导入 log4j 依赖即可，Maven 地址：https://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

整合JDBCTemplate进行crud
导入log4j依赖

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

现在需要程序员自己为 DruidDataSource 绑定全局配置文件中的参数，再添加到容器中，而不再使用 Spring Boot 的自动生成了；我们需要自己添加 DruidDataSource 组件到容器中，并绑定属性；

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DruidConfig {

    /*
       将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建
       绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效
       @ConfigurationProperties(prefix = "spring.datasource")：作用就是将 全局配置文件中
       前缀为 spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中
     */
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }
}

测试类中测试

@SpringBootTest
class SpringbootDataJdbcApplicationTests {

    //DI注入数据源
    @Autowired
    DataSource dataSource;

    @Test
    public void contextLoads() throws SQLException {
        //看一下默认数据源
        System.out.println(dataSource.getClass());
        //获得连接
        Connection connection =   dataSource.getConnection();
        System.out.println(connection);

        DruidDataSource druidDataSource = (DruidDataSource) dataSource;
        System.out.println("druidDataSource 数据源最大连接数：" + druidDataSource.getMaxActive());
        System.out.println("druidDataSource 数据源初始化连接数：" + druidDataSource.getInitialSize());

        //关闭连接
        connection.close();
    }
}

配置Druid数据源日志监控

Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看，类似安装路由器时，人家也提供了一个默认的 web 页面。

所以第一步需要设置 Druid 的后台管理页面，比如登录账号、密码等；配置后台管理；

//配置 Druid 监控管理后台的Servlet；
//内置 Servlet 容器时没有web.xml文件，所以使用 Spring Boot 的注册 Servlet 方式
@Bean
public ServletRegistrationBean statViewServlet() {
    ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");

    // 这些参数可以在 com.alibaba.druid.support.http.StatViewServlet 
    // 的父类 com.alibaba.druid.support.http.ResourceServlet 中找到
    Map<String, String> initParams = new HashMap<>();
    initParams.put("loginUsername", "admin"); //后台管理界面的登录账号
    initParams.put("loginPassword", "123456"); //后台管理界面的登录密码

    //后台允许谁可以访问
    //initParams.put("allow", "localhost")：表示只有本机可以访问
    //initParams.put("allow", "")：为空或者为null时，表示允许所有访问
    initParams.put("allow", "");
    //deny：Druid 后台拒绝谁访问
    //initParams.put("kuangshen", "192.168.1.20");表示禁止此ip访问

    //设置初始化参数
    bean.setInitParameters(initParams);
    return bean;
}

配置完毕后，访问：http://localhost:8080/druid/login.html

进行账号密码登录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BTic6BZZ-1663507052226)(springboot笔记/image-20220918154155557.png)]

配置 Druid web 监控 filter 过滤器

//配置 Druid 监控 之  web 监控的 filter
//WebStatFilter：用于配置Web和Druid数据源之间的管理关联监控统计
@Bean
public FilterRegistrationBean webStatFilter() {
    FilterRegistrationBean bean = new FilterRegistrationBean();
    bean.setFilter(new WebStatFilter());

    //exclusions：设置哪些请求进行过滤排除掉，从而不进行统计
    Map<String, String> initParams = new HashMap<>();
    initParams.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*");
    bean.setInitParameters(initParams);

    //"/*" 表示过滤所有请求
    bean.setUrlPatterns(Arrays.asList("/*"));
    return bean;
}

平时在工作中，按需求进行配置即可，主要用作监控。

整合mybatis

官方文档：http://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

Maven仓库地址：https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter/2.1.1

导入spring web、JDBC、mysql、Druid、mybatis、lombok依赖

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
<!--		JDBC API-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
<!--		mysql Driver-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<!-- druid-spring-boot-starter -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.2.6</version>
		</dependency>
		<!-- mybatis-spring-boot-starter -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.1.3</version>
		</dependency>
	</dependencies>

创建实体类、mapper接口、service、controller文件
创建User实体类

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer role;
}

编写mapper接口方法，添加@Mapper使该文件被扫描到

@Mapper  //该注解和在主启动类添加@MapperScan注解一样，二选一
public interface UserMapper {
    List<User> queryAllUsers();
    User queryUserById(Integer id);
    int addUser(User user);
    int updateUser(User user);
    int deleteUserById(Integer id);
}

在resource下创建mybatisMapper文件夹，并创建UserMapper.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.jia.mapper.UserMapper">
    <select id="queryAllUsers" resultType="user">
        select * from `user`
    </select>

    <select id="queryUserById" resultType="user">
        select * from `user` where id=#{id}
    </select>

    <insert id="addUser">
        insert into `user` values(null,#{username},#{password},#{role})
    </insert>

    <update id="updateUser">
        update `user` set
        `password` = #{password}
        where `id` = #{id}
    </update>

    <delete id="deleteUserById">
        delete from `user` where `id`=#{id}
    </delete>
</mapper>

yaml文件中配置数据库DataSource连接属性及配置好mybatis属性

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/yeujuan?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    
mybatis:
  type-aliases-package: com.jia.entity   #设置别名
  mapper-locations: classpath:mybatisMapper/**     #扫描到mapper映射的xml文件

注意：

classpath：/ 表示从项目根路径开始扫描

写好service层和controller层，然后进行测试

service层：

import com.jia.entity.User;
import com.jia.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    UserMapper userMapper;

    public List<User> queryAllUsers(){
        return userMapper.queryAllUsers();
    }

    public User queryUserById(Integer id){
        return userMapper.queryUserById(id);
    }
    public String addUser(User user){
        int i = userMapper.addUser(user);
        if(i==1){
            return "添加成功";
        }else{
            return "添加失败，请联系管理员";
        }
    }
    public String updateUser(User user){
        int i = userMapper.updateUser(user);
        if(i==1){
            return "更新成功";
        }else{
            return "更新失败，请联系管理员";
        }
    }
    public String deleteUserById(Integer id){
        int i = userMapper.deleteUserById(id);
        if(i==1){
            return "删除成功";
        }else{
            return "删除失败，请联系管理员";
        }
    }
}

controller层：

import com.jia.entity.User;
import com.jia.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    @Autowired
    UserService userService;

    @GetMapping("/queryAll")
    public List<User> queryAllUsers(){
        return userService.queryAllUsers();
    }
    @GetMapping("/queryUserById")
    public User queryUserById(Integer id){
        return userService.queryUserById(id);
    }
    @GetMapping("/addUser")
    public String addUser(User user){
        return userService.addUser(user);
    }
    @GetMapping("/updateUser")
    public String updateUser(User user){
        return userService.updateUser(user);
    }
    @GetMapping("/deleteUserById")
    public String deleteUserById(Integer id){
        return userService.deleteUserById(id);
    }
}

早餐有胃口吗

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
SpringBoot（二）web开发_thymeleaf的使用_mvc扩展_error页_拦截器_mybatis-druid整合

静态资源导入、首页和图标、themeleaf模板引擎、MVC自动配置及扩展、拦截器和404页面、JDBC-Druid-mybatis整合
复制链接

扫一扫