SpringBoot初识

最新推荐文章于 2022-11-01 20:19:50 发布

Maggie~~

最新推荐文章于 2022-11-01 20:19:50 发布

阅读量141

点赞数

分类专栏： spring-boot 文章标签： java

本文链接：https://blog.csdn.net/qq_51347907/article/details/115758333

版权

spring-boot 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

> 概念

Spring Boot是一个框架的搭建技术。其目的是简化Spring应用的初识搭建以及开发过程。

优点：

1，简化配置 1）减少配置，2）优化配置

2，简化部署

3，简化监测

4,与主流框架的无缝集成

>SpringBoot核心文件

1,pom文件

有三个依赖

1）父依赖spring-boot-starter-parent

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

作用：

1，限定Java版本，SpringBoot2.1.5版本所依赖的JDK版本为1.8及以上。

2，限定源码的文本编码方式：默认为UTF-8

3，管理依赖。在父依赖中设置一些公共的版本号等

4，打包支持：设置了一些使用maven对项目进行打包的规则。

5，动态识别资源

6，识别插件配置。

2）依赖spring-boot-starter-web

每个依赖都可以到maven仓库中找到对应的资源文件，可以通过这些资源了解spring-boot-starter-web依赖。spring-boot-starter-web依赖了很多其他的组件。

3）依赖spring-boot-start-test

>引入项目测试所需要的组件，不是必需的

2，启动类

启动类是一个main()方法，其上有一个注解@Spring Boot Application。该注解包括7个注解。

Java提供的有

@Target

@Retention

@Documented

@Inherited

Springboot提供的有

@SpringBootConfiguration

此注解可替换Spring的applicationContext.xml配置文件，被注解的类内部可以包含一个或多个被@Bean注解标注的方法，这些方法会被Spring的系统类扫描，并用于构建Bean定义，初始化Spring容器。

@EnableAutoConfiguration

此注解可以启动SpringBoot的自动配置。

Spring提供的有

@ComponentScan

扫描启动类同目录及子目录下的所有注解，是注解生效。

3，application.properties文件或application.yml文件

此文件是SpringBoot项目的配置文件，关于SpringBoot项目的大部分配置信息可以在此文件中进行编写。

此文件必须放在项目的resources资源路径的根路径下。

yml文件编写注意点

1,大小写敏感。

2，缩进时，不能使用Tab键，只允许有空格。

3，属性值和属性名之间要有空格隔开。

4，Spring Boot项目启动方式

1，使用内置web容器启动

2，在本地Web容器中启动

3，使用Maven启动项目。在idea的terminal窗口中输入mvn spring-boot：run命令

4，使用Java命令启动。在idea的terminal窗口中进入项目的根路径,输入java -jar 项目名.jar。停止项目Ctrl+C

> JUnit测试常用注解

@SpringBootTest:创建Spring的ApplicationContext对象，并将其注入到测试类中。

@BeforeEach:在测试方法之前添加的内容

@AfterEach:在测试方法后添加的内容

@Test:测试方法上添加的注解

> 读取配置文件

在springBoot项目中使用Value注解，获取application配置文件中信息。

@Value:此注解用在实体类的属性上，写法： @Value("${xx.xxx}") xx代表配置文件中的前缀，xxx代表子一级

@ConfigurationProperties：用于类上，需要搭配setter方法一起使用。写法：@ConfigurationProperties(prefix = “user”) 前缀用来标识对应的实体类。

eg:

1）

application.yml文件中

users:
  names: zhangsan
  pwd: 1234

user类中

package com.example.test.util;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component//添加注解--自动装配实体类
public class User {
    @Value("${user.names}")//取配置文件中的值，并赋予属性
    private String names;
    @Value("${user.pwd}")//取配置文件中的值，并赋予属性
    private String pwd;

    @Override
    public String toString() {
        return "User{" +
                "names='" + names + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    public String getNames() {
        return names;
    }

    public void setNames(String names) {
        this.names = names;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

测试执行即可

2）

application.yml文件中

user:
  names: zhangsan
  pwd: 1234

user类中

package com.example.test.util;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component//添加注解--自动装配实体类
@ConfigurationProperties(prefix = "user")//使用此注解,需要添加前缀来标识对应的实体类，避免属性同名的问题，并配合setter方法进行注入
public class User {
    private String names;
    private String pwd;

    @Override
    public String toString() {
        return "User{" +
                "names='" + names + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    public String getNames() {
        return names;
    }

    public void setNames(String names) {
        this.names = names;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

测试执行即可

> 多环境配置

2种方式

1）

在这里插入图片描述

创建多个application配置文件

application-dev.xml文件中

spring:
  profiles: dev
server:
  port: 8081

application-test.xml文件中

spring:
  profiles: test
server:
  port: 8084

application.xml文件中

spring:
  profiles:
    active: test

2)在同一配置文件中添加多个环境，并用 — 隔开，使用那个环境就激活。

spring:
  profiles:
    active: test
---
spring:
  profiles: test
server:
  port: 8084
---
spring:
  profiles: dev
server:
  port: 8081

启动项目后观察输出到控制台的端口号的变化

> SpringBoot的自动配置

eg:创建一个项目，在此项目中创建SayHello,SayHelloAutoConfiguration,SayHelloProperties这3个类。

package com.auto.demo;

//核心类，此种编写自动配置的核心业务，此类未添加任何注解，
// 默认情况下，不会被spring框架识别，更不会被spring框架实例化
public class SayHello {

    private String hellomsg;
    public String sayHello(){
        return "hello====，"+hellomsg;
    }

    public String getHellomsg() {
        return hellomsg;
    }

    public void setHellomsg(String hellomsg) {
        this.hellomsg = hellomsg;
    }
}

package com.auto.demo;

import org.springframework.boot.context.properties.ConfigurationProperties;

//此类的作用是读取application.yml文件中配置以hello为前缀，名为helloMsg的属性的值，
// 这里给的默认值是springBoot
@ConfigurationProperties(prefix = "hello")
public class SayHelloProperties {
    private String helloMsg="springBoot";

    public String getHelloMsg() {
        return helloMsg;
    }

    public void setHelloMsg(String helloMsg) {
        this.helloMsg = helloMsg;
    }
}

#yml配置文件
hello:
  helloMsg: mybatis

package com.auto.demo;


import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
//让此类变成一个配置类
@Configuration
//用于判断某些类存在时进行后续代码的操作
@ConditionalOnClass({SayHello.class})
//为某个类中的属性赋值
@EnableConfigurationProperties({SayHelloProperties.class})
//ConditionalOnProperty注解的作用是通过prefix，value,matchIfMissing三个属性来决定是否给项目提供SayHello实例
//matchIfMissing=false,则必须在application.yml中找到指定的prefix为hello，名称为helloMsg的配置项，若找不到，则自动配置无法提供此实例
//matchIfMissing=true,不管application.yml中是否有配置项，自动配置都会给项目提供此实例
@ConditionalOnProperty(prefix = "hello",value = "helloMsg",matchIfMissing = true)
//此类是自动配置条件判断类，判断是否满足自动配置的条件，如果满足则完成自动配置
public class SayHelloConfiguration {
    @Resource
    private SayHelloProperties sayHelloProperties;

    @Bean
    @ConditionalOnMissingBean({SayHello.class})
    public SayHello sayHello(){
        SayHello sayHello = new SayHello();
        sayHello.setHellomsg(sayHelloProperties.getHelloMsg());
        return sayHello;

    }

}

测试类

package com.auto.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    ApplicationContext context;

    @Test
    void contextLoads() {
        SayHello bean = context.getBean(SayHello.class);
        String result = bean.sayHello();
        System.out.println(result);
    }
}

> SpringBoot整合JSP

SpringBoot默认支持的模板引擎有4种：FreeMarker，Groovy，Thymeleaf，Mustache

默认不支持jsp,但是可以引入相关依赖来整合jsp模板引擎

步骤

1，添加依赖

<!--添加jsp模板的相关依赖、、、标签库，tomcat的支持-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>
        </dependency>
               <!-- JSTL 标签库 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <!-- tomcat 支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <!-- <scope>provided</scope>-->
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

2，在application配置文件种配置视图解析器

spring:
  mvc:
    view:
      prefix: /WEB-INF/jsp/
      suffix: .jsp

3，编写控制器

//正常编写Controller层代码
package com.example.demo.controller;

import com.sun.deploy.net.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpSession;

@Controller
public class HomeController {

    @RequestMapping("/index")
    public String show(HttpSession session){
        session.setAttribute("h","hello");
        return "index";
    }
}

4，编写jsp页面

<!--正常编写jsp页面代码-->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>${h}</h1>
</body>
</html>

5，启动项目测试

> 使用XML的配置

使用@ImportResource注解解读XML配置文件

步骤

1，将@ImportResource注解标注到启动类上，或者某个配置类（即添加了@Configuration注解到类）上。

2，指定要引入的xml配置文件的位置。eg:@ImportResource(value=“classpath:applicationContext.xml”)。

语法：

@ImportResource（value=“配置文件的位置”）

> LogBack日志

日志的元素构成：

1,日志时间：精确到毫秒

2,日志级别：6种，低–>高 :trace<debug<info<warn<error<fatal,默认info

3,进程ID:日志所属进程ID,INFO后的数字，即为进程ID

4,分隔符： —

5,线程名：使用中括号括起来的内容

6,日志名：默认使用源代码的类名。

7,日志内容：冒号左侧的内容。

application配置文件，配置日志属性

属性	作用
logging.config	加载指定位置的日志配置文件
logging.file.max-history	保留的存档日志文件的最大数目
logging.file.max-size	日志文件的最大占用空间，单位为MB
logging.level.*	设置日志级别
logging.pattern.console	设置在控制台输出的日志格式
logging.pattern.dateformat	设置在控制台输出的日志的日期格式
logging.pattern.file	定义输出到日志文件的日志格式
logging.pattern.level	定义日志的输出级别

logback-spring.xml 文件

<!--日志文件的配置信息-->

<?xml version="1.0" encoding="UTF-8"?>
<configuration  scan="true" scanPeriod="60 seconds" debug="false">
    <contextName>projectName</contextName>
    <property name="contextName" value="my" />
    <property name="log_dir" value="d:/softwareDirectory/logs/" />
    <!--输出到控制台-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 级别过滤器。如果日志级别低于WARN，将被过滤掉。 ALL TRACE DEBUG INFO WARN ERROR-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>DEBUG</level>
        </filter>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %msg - %file:%line%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- 每天记录info级别日志文件 -->
    <appender name="InfoRollingFileAppender"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <Prudent>true</Prudent>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>%d{yyyy-MM-dd HH:mm:ss} [%-5level] %msg - %file:%line%n</Pattern>
        </layout>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${log_dir}/${contextName}_info%d{yyyy-MM-dd}.log
            </FileNamePattern>
        </rollingPolicy>
        <!-- 级别过滤器。如果日志级别低于WARN，将被过滤掉。ALL TRACE DEBUG INFO WARN ERROR-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <!-- 除了DEBUG级别的日志，其它什么级别的日志都不要 -->
        <!-- <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>DEBUG</level>
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY </onMismatch>
        </filter> -->
    </appender>

    <!-- 每天记录ERROR级别日志文件 -->
    <appender name="ErrorRollingFileAppender"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <Prudent>true</Prudent>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>%d{yyyy-MM-dd HH:mm:ss} [%-5level] %msg - %file:%line%n</Pattern>
        </layout>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${log_dir}/${contextName}_error%d{yyyy-MM-dd}.log
            </FileNamePattern>
        </rollingPolicy>
        <!-- 级别过滤器。如果日志级别低于WARN，将被过滤掉。 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
        <!-- 除了DEBUG级别的日志，其它什么级别的日志都不要 -->
        <!-- <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>DEBUG</level>
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter> -->
    </appender>

    <root>
        <appender-ref ref="console" />
        <appender-ref ref="InfoRollingFileAppender" />
        <appender-ref ref="ErrorRollingFileAppender" />
    </root>
</configuration>

其中常用的元素及其作用

1）configuration：配置文件的根节点，包含3个属性

1 scan:设置为true时表示如果配置文件发生改变，将被重新加载，反之则不对配置文件是否发生改变进行检测。默认为true。

2 scanPeriod:设置检测日志配置文件是否有修改的时间间隔。为true时生效，默认时间间隔1分钟。

3 debug: 设置为true时，将输出LogBack默认日志信息，默认为false。

2）contextName:日志的上下文名称。用于区分不同程序的日志。

<!--设置演示-->
package com.example.demo.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpSession;

@Controller
public class HomeController {

    Logger logger= LoggerFactory.getLogger(HomeController.class);


    @RequestMapping("/index")
    public String show(HttpSession session){
        session.setAttribute("h","hello");
        logger.debug("==============================debug");
        logger.info("=======================info");
        logger.warn("====================warn");
        logger.error("==================error");
        return "index";
    }
}

输出结果显示

。。。

3）property:设置变量值，在日志配置文件中使用。

属性： value ：变量的值

name:变量的名称

定义的变量可通过 ${ } 调用

4）appender:配置日志输出的策略,class属性用来指定具体采用输出策略。

常用属性

1 layout:指定日志格式，在ConsoleAppender控制台输出策略种使用。

2 encoder:指定日志格式，在RollingFileAppender文件输出策略种使用。（此策路下使用必须指定）

常见的日志格式及含义

配置	含义
%d{HH: mm:ss.SSS}	日志输出时间
%thread	输出日志的进程名称
%-5level	日志级别，并且使用5个字符靠左对齐
%logger{36}	日志输出者的名字
%msg	日志的信息内容
%n	换行符

5）filter：日志过滤器，常用的时LevelFilter级别过滤器，

<!--配置演示-->
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <!-- 除了DEBUG级别的日志，其它什么级别的日志都不要 -->
        <!-- <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>DEBUG</level>
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY </onMismatch>
        </filter> -->

6）file:当输出日志到文件时，指定文件的路径和文件名，可以是相对路径或绝对路径。如果上级目录不存在会自动创建，没有默认值。

7）rollingPolicy:日志输出时的循环策略。常用的为TimeBasedRollingPolicy。日期的最小单位为小时。

<!--配置演示-->
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${log_dir}/${contextName}_error%d{yyyy-MM-dd}.log
            </FileNamePattern>
        </rollingPolicy>

fileNamePattern和file同时存在时，只有fue会生效。

8）root:设置日志输出级别和采用那种日志输出策略。属性level用来指定日志输出级别。

子元素appender-ref用来设置日志的输出策略。

> java配置的方式

主要通过两个注解

@Configuration：标注在一个java类上，此类便具有了和Spring的Ioc配置文件相同的功能，即被@Configuration标注的类，可实现Bean组件管理。

@Bean:作用于方法上，被@Bean注解标注的方法返回的实例，才能被成为Bean组件。此注解标注的方法名即为Bean组件的id。被标注的方法返回的类型，即为配置Bean组件所需的class属性的值。@Bean注解的name属性可以指定组件的id值。

实体类

//实体类--Employee
public  class  Employee() { 
    private String name;
         public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    }

配置类

//配置类
@Configuration
public class JavaConfig { 
    @Bean
    public  Employee  employee() { 
        Employee employee = new Employee();
        employee.setUserName("小明");
        return employee;
    }
}

测试类

//测试类
 @Autowired
    private ApplicationContext context;

    @Test
    void testEmploy() {
        Employee employee = context.getBean(Employee.class);
        System.out.println("输出=================="+employee.getName());
    }

测试类中AnnotationConfigApplicationContext类时ApplicationContext的实现类之一，用于管理Java配置的方式生成Spring容器。测试首先通过AnnotationConfigApplicationContext获取Spring Ioc容器的上下文信息，再在上下文信息中获取员工类的Bean组件。

通过Java配置的方式，可以在方法中通过java代码完成设置注入，本质上时给类的属性赋值的过程。

>java配置方式拓展

@Scope注解，标注到方法上，与@Bean注解搭配使用 ,指定Bean组件的作用域。eg: ‘@Scope(“prototype”)’ ,@Scope(“singleton”):默认。

@Bean注解的属性

initMethod属性
作用：被标注的方法用于容器启动前执行
使用方法：@Bean(initMethod=“Bean中的初始化方法名”)

destroyMethod属性
作用：被标注的方法将于容器销毁前执行
使用方法：@Bean(destroyMethod=“Bean中的销毁方法”)

eg:

在Employee实体类中添加方法

   public void before() {
        System.out.println("=============before");
    }
    public void after() {
        System.out.println("=============after");
    }

配置类中

import com.example.demo.pojo.Employee;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EmployConfig {

    @Bean(initMethod = "before",destroyMethod = "after")//指定初始化调用方法，销毁调用方法
    public Employee employee(){
        Employee employee = new Employee();
        employee.setName("张三");
        return employee;
    }
}

然后测试一下，显示结果
在这里插入图片描述

> SpringBoot整合mybatis

方法一：myBatis-spring方式

步骤：

1，引入依赖—mybatis包，myBatis-spring整合包,指定xml的位置

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.1</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<!--在bulid标签内添加xml位置-->
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.xml</include>
        </includes>
    </resource>
</resources>

2，编写配置信息—
在yml文件中配置DataSource数据源，

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: mysql://localhost:3306/mall?serverTimezone=GMT%2B8&...
    username: 数据库用户名
    password: 数据库密码

配置SqlSessionFactoryBean（创建工具类，添加配置类注解，注入数据源，使用Bean注解构建SqlSessionFactoryBean）

@Bean
public SqlSessionFactory sqlSessionFactoryBean() {
    SqlSessionFactoryBean sqlSFBean= new SqlSessionFactoryBean();
    try {
        // 设置数据源
 	  sqlSFBean.setDataSource(dataSource);  
        // 为指定包下的类设置别名
        sqlSFBean.setTypeAliasesPackage("com.zhmbjavaconf.demo.entity");
        return sqlSFBean.getObject();
    } catch (Exception e) {throw new RuntimeException();
}

配置MapperScannerConfigurer（创建MyBatisConf配置类，构建MapperScannerConfigurer对象）

@Configuration
public class MyBatisConf {
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
 	 MapperScannerConfigurer msc = new MapperScannerConfigurer ( ) ;
        // 通过SqlSessionFactoryBean生产SqlSessionFactory实例       
	 msc.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");
        // 定义扫描的包
	 msc.setBasePackage("com.zhmbjavaconf.demo.mapper");
        return mapperScannerConfigurer;
    }
}

方法二：mybatis-spring-boot-starter方式

步骤：

1，pom.xml文件中引入依赖

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.1</version>
</dependency>
<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
</dependency>

2，yml文件中编写配置信息

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=utf-8
    username: 数据库用户名
    password: 数据库密码
#用于配置映射文件位置，需起别名的Entity包位置
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.zhmbanno.demo.entity

3，mapper接口上添加注解@Mapper，或者在启动类上添加@MapperScan注解，指定mapper接口的位置。

4,逐层编写代码，并测试。

> SpringBoot整合Redis

步骤

1，引入依赖

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

2，配置Redis连接

spring:
  redis:
    host: Redis服务的IP
    port: Redis服务端口，通常为 6379
    password: 连接Redis服务的密码
    database: 0  #代表0号库

3，创建RedisTemplate的Bean组件

@Configuration
public class RedisConfig {
    @Bean
    // 参数RedisConnectionFactory为Spring Boot自动注入
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
}

4，创建工具类
在工具类中封装向Redis存储，查询数据的方法，注入RedisTemplate

public boolean set(String key, Object object){ //向Redis中缓存数据
    ValueOperations<String, Object> vo = redisTemplate.opsForValue();
    vo.set(key, object);
    return true;
}

public Object get(String key){ //根据key从Redis中获取数据
    ValueOperations<String, Object> vo = redisTemplate.opsForValue();
    return vo.get(key);
}

5，测试

> 数据源和事务

配置DBCP2数据源连接池

1.添加依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    <version>2.6.0</version>
</dependency>

2，编写配置文件

spring:
  datasource:
    driver-class-name: 数据库驱动名
    url: 数据库连接地址
    username: 数据库用户名
    password: 数据库密码
    #指定数据源的类型，否则SpringBoot仍会使用内置的数据源
    type: org.apache.commons.dbcp2.BasicDataSource
    dbcp2:
      max-idle: 10
      max-total: 50

事务控制

@Transactional

用到类上，表示作用于当前类的所有方法
用到方法上，表示作用于当前方法

@EnableTransactionManagement,添加到启动类

扩展：

设置事务传播特性

@@Transactional(propagation=Propagation. REQUIRED)
默认使用：REQUIRED

设置事务隔离级别

@Transactional(isolation=Isolation. DEFAULT)
默认使用数据库的隔离级别

设置使用的事务管理器

@Transactional(value=“事务管理器的名称”)

Maggie~~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot初识

> 概念Spring Boot是一个框架的搭建技术。其目的是简化Spring应用的初识搭建以及开发过程。优点： 1，简化配置 1）减少配置，2）优化配置 2，简化部署 3，简化监测 4,与主流框架的无缝集成>SpringBoot核心文件1,pom文件有三个依赖 1）父依赖spring-boot-starter-parent <parent> <groupId>org.springframework.boo
复制链接

扫一扫

专栏目录