> 概念
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=“事务管理器的名称”)