Spring Boot
1.微服务
1.1什么是微服务架构
微服务是一种架构风格(可以对比mvc三层架构,mvvm前端架构对比),要求我们在开发一个应用的时候,这个应用必须构建成一系列小的服务组合。可以通过http的方式进行互通。其演变过程:
1.1.1单体应用架构
单体应用架构(all in one)是指,将一个应用中的所有应用服务都封装在一个应用中
好处:易于开发和测试,方便部署
缺点:修改任何一处都需要关掉服务器,重新打包和部署。不利于大型项目的维护和分工
1.1.2微服务架构
打破all in one的架构方式,每个工功能元素独立起来。独立的元素动态组合,需要哪一些功能元素就拿来组合,
简而言之,微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法,每个小服务都在自己的进程中运行并与轻量级机制(通常是HTTP资源API)进行通信。这些服务围绕业务功能构建,并且可以由全自动部署机制独立部署。这些服务的集中管理几乎没有,可以用不同的编程语言编写并使用不同的数据存储技术。
相关文献推荐:微服务论文(马丁·福勒) - 简书 (jianshu.com)
一个大型系统的微服务架构,就像一个复杂交织的神经网络,每个神经元就是一个功能元素,他们各自完成自己的功能,然后通过http相互请求调用,但是这种庞大的系统架构给部署和运维带来很大的难度,即spring带来了大型分布式服务的全套,全程产品
- springboot构建一个个独立的微服务应用单元,帮我们快速构建一个应用
- springcloud完成大型分布式网络服务调用,实现分布式
- spring cloud data flow在分布式中间进行流式数据计算,批处理
组件是独立可替换和可升级的软件单元。
我们将库定义 为链接到程序中并使用内存中函数调用进行调用的组件
而服务则是进程外组件,它们通过某种机制(例如Web服务请求或远程过程调用)进行通信。(这与许多OO程序中的服务对象的概念不同[3]。)
2.第一个Spring Boot程序
springboot提供快速生成的网站,官网下载后解压导入idea
同时idea也集成了该网站功能,直接使用idea创建一个springboot项目
也可生成一个空白的springboot项目,然后导入web包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
在application.properties包里,基本配置可以更改端口号:
server.port=8081
2.1自动装配原理
springboot是通过main方法下的SpringApplication.run方法启动的,启动的时候他会调用refshContext方法,先刷新容器,然后根据解析注解或者解析配置文件的形式祖册bean,而它是通过启动类的SpringBootApplication注解进行开始解析的,他会根据EnableAutoConfiguration开启自动化配置,里面有个核心方法ImportSelect选择性的导入,根据loadFanctoryNames根据classpash路径以MATA-INF/spring.factorces下面以什么什么EnableAutoConfiguration开头的key去加载里面所有对应的自动化配置,他并不是把这一百二十多个自动化配置全部导入,在他每个自动化配置里面都有条件判断注解,先判断是否引入相互的jar包,再判断容器是否有bean再进行注入到bean容器
pom.xml
-
核心依赖都在父工程中 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.7.4</version> <relativePath/> <!-- lookup parent from repository --> </parent>
启动器
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
- 启动器:就是springboot的启动场景。如spring-boot-starter-web会自动导入web环境所有依赖
- springboot会将所有功能场景,编程一个个启动器。需要什么功能,只需要找到所需要启动器即可
主程序(@SpringBootApplication 主程序类标志)
springboot所有的自动配置文件都是在启动的时候扫描并加载:
spring.factories所有的自动配置类都在这里,但是不一定生效,因为需要满足ConditionalOnClass()里面所有的条件,其中就必须包括启动类,只有导入了相关的star启动器,这些自动装配的包才有效
-
SpringBoot在启动的时候,从类路径下/META-INF/spring.factories获取指定的值
-
将这些自动配置的类导入容器,自动配置类就会生效,帮我们进行自动配置
-
以前我们需要自动配置的东西,现在不需要了
-
整合javaEE,解决方案和自动配置的东西都在Spring-boot-autoconfigure下
-
它会把所有需要导入的组件,以类名的方式返回这些组件,这些组件就会被添加到容器
-
容器中也会存在非常多的XXXAutoConfigure的文件(@Bean),就是这个类给容器导入了这个场景所需要的所有组件并自动配置
2.2主程序
SpringApplication.run()
1.推断应用的类型是普通的项目还是web项目
2.查找并加载所有可用初始化器,设置到initializers属性中
3.找出所有的应用程序监听器,设置到listeners中
4.推断并设置main方法的定义类,找到运行的主类(加载主类)
3.配置文件
yaml是一种标记语言(对空格的要求十分严格),语法: k: v
# 普通的key-value
name: tzf
#对象
student:
name: tzf
age: 18
#行内写法
student: {name: tzf , age: 18}
#数组
pets:
-cat
-dog
-pig
pets: [cat,dog,pig]
xxxconfigeration组件装配了大量的xxxpropertiesz自动装配类,我们在yaml的配置其实就是在给xxxpropertiesz自动装配类的属性赋值,以达到自动配置的效果。
另外我们可以通过在yaml配置debug=true在控制台输出查看哪些配置以及开启,哪些还未开启
还有就是并不是所有的xxxautoconfigeration自动装配都会起作用,因为这些自动装配类内部都有@ConditionalOneClass(xxx,xxx,xxx),只有满足@ConditionalOneClass这个注解里面所有条件,被注解的配置类才会起作用,而这些条件就包括一个个的start启动类
3.1个属性赋值的几种方式
1.使用@Value("...")注解
@Value("旺财")
private String name;
@Value("1")
private Integer age;
2.使用yml配置文件对对象赋值
注意:实体类需要用到@ConfigurationProperties(prefix = "person"),与配置文件yaml里的对象相对应
Person
@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
@ConfigurationProperties(prefix = "person")
public class Person {
private String name;
private Integer age;
private Boolean happy;
private Date birth;
private Map<String,Object> map;
private List<Object> lists;
private Dog dog;
}
yaml
person:
name: tzf
age: 18
happy: true
birth: 2022/10/14
map: {k1: v1,k2: v2}
lists:
- cat
- dag
- girl
dog:
name: 旺财
age: 1
测试类
@SpringBootTest
class Spring01HelloworldApplicationTests {
@Autowired
Person person;
@Test
void contextLoads() {
System.out.println(person);
}
}
3.使用.propertysource配置文件(了解,这里不做详细介绍)
3.2配置文件的优先级
1.file:./config/ (根目录下的config包下的配置文件)
2.file:./ (根目录下的配置文件)
3.classpath:/config/ (java/resource下的config下的配置文件)
4.classpath:/ (java/resource下的配置文件)
3.3springboot的多环境配置文件,可以选择激活哪一个配置文件
server:
port: 8080
spring:
profiles:
active: test
---
server:
port: 8081
spring:
profiles: dev
---
server:
port: 8082
spring:
profiles: test
#最后测试的结果用的是8082端口号
下一个问题,配置文件能配那些设置?
其实xxx.properties或xxx.yml文件能配置的东西是固定,@ConfigurationProperties()与你写的配置文件绑定,其默认值都写在@xxxproperties里面,如果想修改默认值,按照对应配置规则去配置
精髓:
1、SpringBoot启动会加载大量的自动配置类
2、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中;
3、我们再来看这个自动配置类中到底配置了哪些组件;(只要我们要用的组件存在在其中,我们就不需要再手动配置了)
4、给容器中自动配置类添加组件的时候,会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可;
xxxxAutoConfigurartion:自动配置类;给容器中添加组件
xxxxProperties:封装配置文件中相关属性;
3.4读取yaml数据方式
方式一:
使用@Value读取单个数据,属性名引用方式:${一级属性名.二级属性名……}
lesson: SpringBoot
server:
port: 82
enterprise:
name: itcast
age: 16
tel: 4006184000
subject:
- Java
- 前端
- 大数据
@RestController
@RequestMapping("/books")
public class BookController {
@Value("${lesson}")
private String lessonName;
@Value("${server.port}")
private int port;
@Value("${enterprise.subject[1]}")
private String[] subject_01;
}
baseDir: /usr/local/fire
center:
dataDir: ${baseDir}/data
tmpDir: ${baseDir}/tmp
logDir: ${baseDir}/log
msgDir: ${baseDir}/msgDir
方式二:
封装全部数据到Environment对象
lesson: SpringBoot
server:
port: 82
enterprise:
name: itcast
age: 16
tel: 4006184000
subject:
- Java
- 前端
- 大数据
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
private Environment env;
@GetMapping("/{id}")
public String getById(@PathVariable Integer id){
System.out.println(env.getProperty("lesson"));
System.out.println(env.getProperty("enterprise.name"));
System.out.println(env.getProperty("enterprise.subject[0]"));
return "hello , spring boot!";
}
}
方式四:
自定义对象封装指定数据的作用
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
username: root
password: root
@Component
@ConfigurationProperties(prefix = "datasource")
public class DataSource {
private String driverClassName;
private String url;
private String userName;
private String password;
}
4.JSR303数据校验
松散绑定:即"ab"可以用“a-b"表示
JSR303数据校验 : 这个就是我们可以在字段是增加一层过滤器验证 , 可以保证数据的合法性
使用需要先添加依赖
<!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.0.16.Final</version>
</dependency>
- 类似于html页面的input的type属性,指定类型
<input type="text">
springboot中使用jsp303需要@Validated注解
Bean Validation 中内置的 constraint
Hibernate Validator 附加的 constraint
@Validated
public class Person {
@Email(message = "邮件文件格式错误")
private String email;//属性email必须符合邮件格
}
静态资源导入:
1.在springboot中,我们可以使用一下方式处理静态资源
- webjars localhost:8080/webjars/
- public,static,/**,resources localhost:8080/
优先级:resources>static(默认)>public
5.Thymeleaf引擎模板
之前我们收到前端的html页面,会把它转换成jsp页面,jsp页面可以很轻松把后台数据显示到前端上面,并且实现交互,但是springboot项目 是以jar包,不是以war包,并且我们使用的嵌入式的tomcat不支持jsp。然而纯静态页面无法实现交互,所以springboot推荐我们使用模板引擎,如freemarker,其实jsp也是一种模板引擎,以及springboot推荐我们使用的thymeleaf。
1.导入相关启动器依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
2.创建templates包,将静态网页放在templates中
原因:约定大于配置,springboot的配置文件ThymeleafProperties表明文件的前缀和后缀
public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";
首页面模式
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Good Thymes Virtual Grocery</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<link rel="stylesheet" type="text/css" media="all"
href="../../css/gtvg.css" th:href="@{/css/gtvg.css}" />
</head>
<body>
<p th:text="#{home.welcome}">Welcome to our grocery store!</p>
</body>
</html>
3.语法表达式
具体参考官网:Tutorial: Using Thymeleaf
-
- Variable Expressions:
${...}
变量 - Selection Variable Expressions:
*{...}
选择 - Message Expressions:
#{...}
消息 - Link URL Expressions:
@{...}
URL - Fragment Expressions:
~{...}
- Variable Expressions:
所有的html元素都被thymeleaf接管替代,格式为:th:元素名
例如:th:class="" th:style=""
<div th:text="${name}"></div>
取后端传来的参数‘name'的值,属性为text,使用时为:th:text=""
字符转义(可识别标签):th:utext=""
遍历的两种方式
<div th:each="user:${users}" th:text="${user}"></div>
<div th:each="user:${users}">[[${user}]]</div>
6.拓展使用springMVC
springboot在自动配置的时候会用到很多组件,会首先看容器中有没有用户配置的文件(如果用户自己配置@Bean),如果有优先使用用户配置文件,没有才会使用默认配置。有些配置存在多个,比如视图解析器,用户配置和默认配置可以结合使用。
扩展MVC使用即我们自己要编写一个@Configeration注解的类,并且类型为WebMvcConfigurer,还不能加@EnableWebMvc注解,如:
import org.springframework.context.annotation.Configuration;
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 addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/tzf").setViewName("success");
}
}
注意:springboot中有很多的xxxConfiguration配置类帮助我们扩展配置,只要我们看到这个类型的类,就说明它在修改和扩展原来的配置功能。
7.整合jdbc
补充@Autowired与@Resource区别
- @Autowired注解是Spring提供的,而@Resource注解是J2EE本身提供的
- @Autowird注解默认通过byType方式注入,而@Resource注解默认通过byName方式注入
- @Autowired注解注入的对象需要在IOC容器中存在,否则需要加上属性required=false,表示忽略当前要注入的bean,如果有直接注入,没有跳过,不会报错
yaml配置数据库DataSource:
spring:
datasource:
url: jdbc:mysql://localhost:3306/mybatis?useUnicode=tru&characterEncoding=utf-8
password: 123456
username: root
driver-class-name: com.mysql.jdbc.Driver
@RestController
public class JdbcController {
@Autowired
JdbcTemplate jdbcTemplate;
@RequestMapping("/userList")
public List<Map<String,Object>> userList(){
String sql="select * from user1";
List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
return maps;
}
@RequestMapping("/userAdd")
public String addUser(){
String sql="insert into user1 values(3,'aa','12345')";
jdbcTemplate.update(sql);
return "add-Success";
}
@RequestMapping("/userupdate/{id}")
public String updateUser(@PathVariable("id")int id){
String sql="update user1 set name = ?,pwd=? where id="+id;
Object[] objects = new Object[2];
objects[0]="tzf6";
objects[1]="520";
jdbcTemplate.update(sql,objects);
return "add-Success";
}
}
8.自定义数据源(DruidDataSource)
第一种自定义整合:
Druid是阿里开源平台数据库连接池的实现,结合了数据库线程池和日志监控
导包:
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.15</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
yaml配置data数据源为的druid
spring:
datasource:
url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
password: 123456
username: root
driver-class-name: com.mysql.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
# 数据源其他配置
#初始化时建立物理连接的个数
initial-size: 5
#最小连接池数量
min-idle: 5
#最大连接池数量 maxIdle已经不再使用
max-active: 20
#获取连接时最大等待时间,单位毫秒
max-wait: 60000
#申请连接的时候检测,如果空闲时间大于timeBetweenEvictionRunsMillis,执行validationQuery检测连接是否有效。
test-while-idle: true
#既作为检测的间隔时间又作为testWhileIdel执行的依据
time-between-eviction-runs-millis: 60000
#销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时,关闭当前连接
min-evictable-idle-time-millis: 30000
#用来检测连接是否有效的sql 必须是一个查询语句
#mysql中为 select 'x'
#oracle中为 select 1 from dual
validation-query: select 'x'
#申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
test-on-borrow: false
#归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
test-on-return: false
# 是否缓存preparedStatement
pool-prepared-statements: true
# 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
#配置监拉统计挡成的filters. stat: 监控统计、Log4j:日志记录、waLL: 防御sqL注入
#如果启用日志记录时报错java.lang.ClassNotFoundException: org.apache.log4j.Priority
#则导入Log4j 依赖即时,Maven 地址: https://mvnrepository. com/artifact/log4j/log4
filters: stat,wall,1og4j
max-pool-prepared-statement-per-connection-size: 20
use-global-data-source-stat: true
connect-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
虽然我们配置了druid连接池的其他属性但是不会生效,因为默认使用的是java.sql.Datasource的类来获取属性的,有些属性datasource没有。如果想要配置生效需要手动创建Druid的配置文件
* 描述: Spring Boot 手动整合 Druid 连接池
*/
// @Deprecated
@Configuration
public class MyDataSourceConfig {
/**
* 配置 Druid 数据源。(Spring Boot 会在 IoC 容器自动读取类型为 DataSource 的对象。故这个 bean 注入后,即与Spring Boot整合好了)
* @return DruidDataSource 数据源
* @throws SQLException
*/
@Bean
@ConfigurationProperties(prefix = "spring.datasource",ignoreUnknownFields = false) // 读取配置文件中的数据源信息。Druid会以此建立数据库连接
public DataSource dataSource() throws SQLException {
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setFilters("stat"); // 开启
return druidDataSource;
}
/**
* (非必要)开启前台监控页面对应的 Servlet,并设置密码(通过 http://域名/druid/index.html 即可访问监控页面)
* 此 Servlet 是由 Druid 提供的 StatViewServlet
* @return
*/
@Bean
public ServletRegistrationBean<StatViewServlet> druidServlet(){
ServletRegistrationBean<StatViewServlet> statViewServletServletRegistrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
statViewServletServletRegistrationBean.addInitParameter("loginUsername","root");
statViewServletServletRegistrationBean.addInitParameter("loginPassword","131121");
return statViewServletServletRegistrationBean;
}
/**
* (非必要)配置Druid的Filter,用于记录 web 请求记录。
* 此 Filter 是由 Druid 提供的 WebStatFilter
* @return
*/
@Bean
public FilterRegistrationBean<WebStatFilter> druidFilter(){
WebStatFilter webStatFilter = new WebStatFilter();
FilterRegistrationBean<WebStatFilter> webStatFilterFilterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
// 除以下路径的访问不记录,其它都会进行记录
webStatFilterFilterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
// 记录 session 时,记录下 session 中记录的用户名
webStatFilterFilterRegistrationBean.addInitParameter("principalSessionName","userName");
return webStatFilterFilterRegistrationBean;
}
}
第二种方法使用starter:
导资源包:
此时就不需要Druid的依赖了,starter中已经包含druid的包了
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.16</version>
</dependency>
配置数据源:
datasource:
url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
password: 123456
username: root
driver-class-name: com.mysql.jdbc.Driver
# 连接池配置:
druid:
initial-size: 2 # 初始化时建立物理连接的个数。默认0
max-active: 10 # 最大连接池数量,默认8
min-idle: 1 # 最小连接池数量
max-wait: 2000 # 获取连接时最大等待时间,单位毫秒。
pool-prepared-statements: false # 是否缓存preparedStatement,也就是PSCache。PSCache对支持游标的数据库性能提升巨大,比如说oracle。在mysql下建议关闭。
max-pool-prepared-statement-per-connection-size: -1 # 要启用PSCache,必须配置大于0,当大于0时,poolPreparedStatements自动触发修改为true。在Druid中,不会存在Oracle下PSCache占用内存过多的问题,可以把这个数值配置大一些,比如说100
# ……druid节点下的其它参数见官方文档:https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E5%88%97%E8%A1%A8
# 启用Druid内置的Filter,会使用默认的配置。可自定义配置,见下方的各个filter节点。
filters: stat,wall
# StatViewServlet监控器。开启后,访问http://域名/druid/index.html
stat-view-servlet:
enabled: true # 开启 StatViewServlet,即开启监控功能
login-username: daniel # 访问监控页面时登录的账号
login-password: 1234 # 密码
url-pattern: /druid/* # Servlet的映射地址,不填写默认为"/druid/*"。如填写其它地址,访问监控页面时,要使用相应的地址
reset-enable: false # 是否允许重置数据(在页面的重置按钮)。(停用后,依然会有重置按钮,但重置后不会真的重置数据)
allow: 192.168.1.2,192.168.1.1 # 监控页面访问白名单。默认为127.0.0.1。与黑名单一样,支持子网掩码,如128.242.127.1/24。多个ip用英文逗号分隔
deny: 18.2.1.3 # 监控页面访问黑名单
# 配置 WebStatFilter(StatFilter监控器中的Web模板)
web-stat-filter:
enabled: true # 开启 WebStatFilter,即开启监控功能中的 Web 监控功能
url-pattern: /* # 映射地址,即统计指定地址的web请求
exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*' # 不统计的web请求,如下是不统计静态资源及druid监控页面本身的请求
session-stat-enable: true # 是否启用session统计
session-stat-max-count: 1 # session统计的最大个数,默认是1000。当统计超过这个数,只统计最新的
principal-session-name: userName # 所存用户信息的serssion参数名。Druid会依照此参数名读取相应session对应的用户名记录下来(在监控页面可看到)。如果指定参数不是基础数据类型,将会自动调用相应参数对象的toString方法来取值
principal-cookie-name: userName # 与上类似,但这是通过Cookie名取到用户信息
profile-enable: true # 监控单个url调用的sql列表(试了没生效,以后需要用再研究)
filter:
wall:
enabled: true # 开启SQL防火墙功能
config:
select-allow: true # 允许执行Select查询操作
delete-allow: false # 不允许执行delete操作
create-table-allow: false # 不允许创建表
# 更多用法,参考官方文档:https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE-wallfilter
9.整合mybatis
整体工程预览:
1.导包:
<!-- 此依赖不是springboot官方提供的-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
2.实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Integer id;
private String name;
private String ped;
}
3.mapper
@Mapper
@Repository
public interface UserMapper {
List<User> userList();
User queryUserById(int id);
int add(User user);
int update(User user);
int delete(int id);
}
4.resource下面配置xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tzf.springboot03mybatis.mapper.UserMapper">
<select id="userList" resultType="User">
select * from user1
</select>
<select id="queryUserById" resultType="User">
select * from user1 where id=#{id}
</select>
<update id="update" parameterType="User">
update user1 set name=#{name},pwd=#{pwd} where id=#{id}
</update>
<insert id="add" parameterType="User">
insert into user1(id,name,pwd) values(#{id},#{name},#{pwd})
</insert>
<delete id="delete" parameterType="int">
delete from user1 where id=#{id}
</delete>
</mapper>
5.yaml配置mybatis
spring:
datasource:
username: root
password: 123456
url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
driver-class-name: com.mysql.cj.jdbc.Driver
#mybatis配置
mybatis:
#起别名
type-aliases-package: com/tzf/springboot03mybatis/pojo
#xml文件与mapper绑定
mapper-locations: classpath:mybatis/mapper/*.xml
#com\tzf\springboot03mybatis\pojo
6.controller层
@RestController
public class UserController {
@Autowired(required = false)
UserMapper userMapper;
// rest行为方法,get查询,post添加,put修改,delete删除
@GetMapping("/userList")
public List<User> userList(){
List<User> userlist = userMapper.userList();
for (User user:userlist) {
System.out.println(user);
}
return userlist;
}
}
rest行为方法get查询,post添加,put修改,delete删除
注意:
@PathVariablez(“xx”)注解,表示简单参数从路径中获取,xx是路径中的参数名字,与形参绑定
@RequestBody参数量比较大,如实体类参数,使用该注解用json格式传参
10.springSecurity
安全验证
官方文档:
https://docs.spring.io/spring-security/site/docs/5.5.8/reference/html5
中文文档:
Introduction · Spring Boot 中文文档 (felord.cn)
(http://felord.cn/_doc/_springboot/2.1.5.RELEASE/_book/)
Spring Security 中文文档 :: Spring Security Reference (springdoc.cn)
1.导包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
11.工程打包与运行
windows环境
可能会遇到的问题:
1.“没有主清单属性”问题,可能是没有引入springboot-maven打包插件
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
springboot打的jar包包含maven打的jar包所有内容,以及程序运行所依赖的环境(比如需要的所有jar包)
2.端口占用问题
linux环境
与windows环境基本一致,注意linux前提配置好jar包运行的换将,如SQL环境,jdk环境
12.临时属性
使用临时属性覆盖原有的属性,因此不同文件位置设置属性是有优先级的,优先级高的文件的属性值会会覆盖掉优先级低的属性值
在jar包运行环境下临时属性设置:
1.使用jar命令启动SpringBoot工程时可以使用临时属性替换配置件中的属性
java -jar springboot.jar --server.port=80
2.临时属性添加方式:java -jar工程名.jar --属性名=值
3.多个临时属性之间使用空格分隔
分
4.临时属性必须是当前boot工程支持的属性,否则设置无效
优先级详情:
参看https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config
在idea环境设置临时属性:
临时属性实则在启动类中作为args参数传入springboot:
@SpringBootApplication
public class Springboot06SsmApplication {
public static void main(String[] args) {
SpringApplication.run(Springboot06SsmApplication.class, args);
//args="server.port=8081"
}
}
如果将启动类中的args参数剔除,则不会有临时属性起作用,断开外部临时配置的入口。
如:
@SpringBootApplication
public class Springboot06SsmApplication {
public static void main(String[] args) {
SpringApplication.run(Springboot06SsmApplication.class);
}
}
同一种文件不同位置优先级:
项目工程/config/application.yml>项目工程/application.yml>resources/config/application.yml>resources/application.yml
不同文件同一位置优先级:
xx.properties>xx.ym>xx.yaml
SpringBoot中4级配置文件
1级: file : config/application.ym 【最高】
2级: file : application.yml
3级: classpath: config/application.yml
4级: classpath: application.yml【最低】
2.作用:
1级与2级留做系统打包后设置通用属性,1级常用于运维经理进行线上整体项目部署方案调控
3级与4级用于系统开发阶段设置通用属性,3级常用于项目经理进行整体项目属性调控
13.多环境开发
yaml版本
spring:
profiles:
active: dev
#生产环境
---
spring:
profiles: dev
server:
port: 8080
#开发环境
---
spring:
profiles: tt #格式过时
server:
port: 8082
#测试环境
---
spring:
config:
activate:
on-profile: zf #新格式
server:
port: 8083
properties版本:
与yaml相同,yaml现在也是使用冲突文件分开的形式,不再写在一个文件里了
多环境分组管理:
spring:
profiles:
active: dev #启动的是dev组而不是单独的某个文件
# include: devDB,devMVC 之前运用的功能
group:
"dev":devDB,devMVC
"pro":proDB,proMVC
#启动配置是dev文件为主,也包括devDB,devMVC文件,有冲突了按照dev文件配置执行,如果dev没有配置则最后文件执行的属性会覆盖前面文件(不包括主文件)冲突的属性
14.整合Redis
是一款key-value存储结构的内存集NoSQL数据库
启动服务器:
redis-server.exe redis.windows.conf
启动服务器之后窗口不要关,新打开一个窗口启动redis
redis-cli.exe -h 127.0.0.1 -p 6379
将Redis启动之后我们来用idea使用,注意此时的Redis服务不要关
首先将Redis相关的配置依赖导入
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>
在yaml文件配置相关信息
spring:
redis:
host: localhost
port: 6379
测试Redis:
@SpringBootTest
class Sptingboot07RedisApplicationTests {
@Autowired(required = false)
RedisTemplate redisTemplate;
@Test
void contextLoads() {
}
@Test
void set(){
// 每一种数据都有不同的操作对象,现获取操作对象然后再对数据进行相关操作
ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set("gtt","mylover");
}
@Test
void get(){
ValueOperations valueOperations = redisTemplate.opsForValue();
Object gtt = valueOperations.get("gtt");
System.out.println(gtt);
}
@Test
void hset()
{
// opsForHash,对hash数据操作对象
HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.put("option","a1","aaa");
}
@Test
void hget(){
HashOperations hashOperations = redisTemplate.opsForHash();
Object o = hashOperations.get("option", "a1");
System.out.println(o);
}
}
注意:
// 以对象操作的基本单元
@Autowired(required = false)
RedisTemplate redisTemplate;
// 以字符串操作的基本单元
@Autowired(required = false)
StringRedisTemplate stringRedisTemplate;
@Test
void get(){
// ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
// System.out.println(ops.get("gtt"));
ValueOperations valueOperations = redisTemplate.opsForValue();
Object gtt = valueOperations.get("gtt");
System.out.println(gtt);
Redis实现客户端切换(jedis):
导包:
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
配置:
spring:
redis:
host: localhost
port: 6379
client-type: jedis
jedis就是基于java语言的redis客户端,集成了redis的命令操作,提供了连接池管理。
lettcus与jedis区别:
springboot默认使用lettcus
- jedis连接Redis服务器是直连模式,当多线程模式下使用jedis会存在线程安全问题,解决方案可以通过配置连接池使每个连接专用,这样整体性能就大受影响。
- lettcus基于Netty框架进行与Redis服务器连接,底层设计中采用StatefulRedisConnection。StatefulRedisConnection自身是线程安全的,可以保障并发访问安全问题,所以一个连接可以被多线程复用。当然lettcus也支持多连接实例一起工作。
15.Mongodb
mysql不够快,redis速度快但是不能结构化,为了满足速度快且能够结构化特点,引入Mongodb存入经常修改的数据的变化
MongoDB是一个开源、高性能、无模式的文档型数据库。NoSQL数据库产品中的一种,是最像关系型数据库的非关系型数据库
iddea整合mongodb
1.导包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
2.在 yaml中配置mongo属性
spring:
data:
mongodb:
uri: mongodb://localhost/test
3.使用MongoTemplet操作MongoDB数据库中的数据
@Autowired
MongoTemplate mongoTemplate;
@Test
void contextLoads() {
Users users = new Users();
users.setAge(18);
users.setName("tzf");
users.setPwd("123456");
mongoTemplate.insert(users);
}
@Test
void FindTest(){
System.out.println(mongoTemplate.findAll(Users.class));
}
16.ES(分布式全文搜索引擎)
倒排索引:
通过提供的数据分词,分词后的关键字对应主键,再根据主键查找详细的信息。此操作大幅度加快了查找的速度
17.mybatisplus小结
mybatisplus的条件查询:
//方式一常规格式
Querywrapper<User> qw = new Querywrapper<User>();//查询年龄大于等于18岁,小于65岁的用户
qw.lt( "age" ,65);
qw.ge( "age",18);
List<User> userList = userDao.selectlist(qw);
system.out.print1n(userList);
//方式二: Lambda格式接条件合海
Querywrapper<User> qw= new Querywrapper<User>( );
qw.Lambda( ).lt(User : : getAge,10);
List<User> userList = userDao.seLectList(qw) ;
System.out.println(userList);
//方式三
LambdaQuerywrapper<User> lqw = new LambdeQueryiwrapper<User>();
//10.到30岁之间,lt小于,gt表示大于
lqw.Lt(user: : getAge,30 ).gt(User: :getAge,10);
//il小子1日岁或者人于30岁,.or()条件或者关系
lqw.lt(User : :getAge,val: 10).or().gt(User: : getAge,val: 30);
//应对参数为空
lqw.lt(null!=uq.getage,User : :getAge,val: 10);
List<User> userList = userDao.selectlist(lqw) ;
system.out.println(userList);
标签:SpringBoot,name,spring,配置,boot,cnblog,public,属性
From: https://www.cnblogs.com/tanzhenfei/p/17662260.html