Spring Boot (入门 起步依赖原理 配置 整合其他框架)
Spring Boot
- SpringBoot 概述
-
- Spring 缺点
- SpringBoot 功能
- 一、入门
- 二、SpringBoot起步依赖原理分析
- 三、SpringBoot配置-配置文件分类
-
- SpringBoot配置-yaml基本语法
- SpringBoot配置-yaml数据格式
- SpringBoot配置-获取数据
- SpringBoot配置-项目内部配置文件加载顺序
- 二、静态页面位置
- 三、拦截器
- 四、配置
- 六、多环境开发
- 七、整合其他框架
-
- junit
- Mybatis和事务
- redis
- MyBatis Plus
SpringBoot 概述
SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻
辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度
上缩短了项目周期。2014 年 4 月，Spring Boot 1.0.0 发布。Spring的顶级项目之一(https://spring.io)。
Spring 缺点
1） 配置繁琐
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多
XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。
Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所
以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但它要求的回报也不少。
2）依赖繁琐
项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导
入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发
进度。
SpringBoot 功能
1） 自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定
Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。
2） 起步依赖
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖
，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
3） 辅助功能
提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
一、入门
依赖
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.1.4.RELEASEversion>
parent>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
dependencies>
2，启动类
@SpringBootApplication
public class HelloApplication {
public static void main(String[] args) {
SpringApplication.run(HelloApplication.class,args);
}
}
二、SpringBoot起步依赖原理分析
-
在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。
-
在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。
-
我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。
三、SpringBoot配置-配置文件分类
SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
-
默认配置文件名称：application
-
在同一级目录下优先级为：properties>yml > yaml
例如：配置内置Tomcat的端口
properties：
server.port=8080
yml:
server: port: 8080
SpringBoot配置-yaml基本语法
- 大小写敏感
- 数据值前边必须有空格，作为分隔符
- 使用缩进表示层级关系
- 缩进时不允许使用Tab键，只允许使用空格（各个系统Tab对应的空格数目可能不同，导致层次混乱）
- 缩进的空格数目不重要，只有相同层级的元素左侧对齐即可
- #表示注释，从这个字符串一直到行尾，都会被忽略
server:
port: 8080
address: 127.0.0.1
name: abc
SpringBoot配置-yaml数据格式
对象(map)：键值对的集合。
person:
name: zhangsan
# 行内写法
person: {name: zhangsan}
数组：一组按次序排列的值
address:
- beijing
- shanghai
# 行内写法
address: [beijing,shanghai]
纯量：单个的、不可再分的值
msg1: 'hello \n world' # 单引忽略转义字符
msg2: "hello \n world" # 双引识别转义字符
参数引用
name: lisi
person:
name: ${name} # 引用上边定义的name值
SpringBoot配置-获取数据
1.@Value注入
2.Evironment
@Autowired
private Environment env;
System.out.println(env.getProperty("person.name"));
System.out.println(env.getProperty("address[0]"));
3.@ConfigurationProperties
1、可以写在类上，通过@Autowired注入即可
2、写在配置文件中，加入这一段，也是一样通过bean，@Autowired注入
SpringBoot配置-项目内部配置文件加载顺序
加载顺序为上文的排列顺序，高优先级配置的属性会生效
- file:./config/：当前项目下的/config目录下
- file:./ ：当前项目的根目录
- classpath:/config/：classpath的/config目录
- classpath:/ ：classpath的根目录
二、静态页面位置
因为是jar文件，那就很奇怪静态页面放哪了？
查询配置文件的源码发现，已经定义了一个位置具体放的位置
这些路径都能放，classpath路径下，也就是 resources这个目录下,都是可以访问的，如有加pages或者包，记得拼接上去
三、拦截器
需要配置两个类，一个类实现HandlerInterceptor接口，实现preHandle方法，变成拦截器类，另一个类当做配置类，配置进mvc容器中
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("-------------");
return true;
}
}
@Configuration
public class MyInter implements WebMvcConfigurer {
@Bean
public HandlerInterceptor getInter(){
return new MyInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(getInter()).addPathPatterns("/**");
}
}
四、配置
Springboot配置文件名称必须是以application开头
六、多环境开发
分为两个，一种是只写一个配置文件，用三个横线—来区分位置，但文件多了会乱，第二种是每个环境写一个单独的配置文件，注意名字前缀必须是application开头，点properties结尾，中间加写内容。
这些文件要使用的时候要记得激活，才能使用。
图中profile要加s
配置文件可以写在多个地方，外部的优先级大于内部的，根目录大于classpath的，config里大于外的，如果有则按优先级最高的使用，忽略其他，如果没有则补充进来
七、整合其他框架
注意一点，引导的位置很重要，因为它的会自动包扫描，扫描同级和它的子包
junit
依赖
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
springboot： 2.1.x版本
@RunWith(SpringRunner.class)
@SpringBootTest(classes = HelloApplication.class)//如果测试类和启动类在同一个包下classes属性可以不写。如果不是就要指定启动类的字节码对象
public class BootTest {
@Autowired
private UserService userService;
@Test
public void testJunit(){
System.out.println(userService.test());
}
}
springboot : 2.2.x版本
@SpringBootTest
class BootTest {
@Autowired
private UserService userService;
@Test
public void testJunit(){
System.out.println(userService.test());
}
}
Mybatis和事务
依赖
<dependencies>
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.1.0version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<scope>runtimescope>
dependency>
dependencies>
数据库连接和包扫描，起别名还是要的。application.properties或者.yml啥的地方写
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://11111:3306/springboot
username: root
password: root
mybatis:
type-aliases-package: com.ybb.domain
mapper-locations: classpath:mapper/*Mapper.xml
实体类
public class User {
private int id;
private String username;
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
dao和mapper
@Mapper
@Repository
public interface UserXmlMapper {
public List<User> findAll();
}
<mapper namespace="com.itheima.springbootmybatis.mapper.UserXmlMapper">
<select id="findAll" resultType="user">
select * from t_user
select>
mapper>
或者
@Mapper
@Repository
public interface UserMapper {
@Select("select * from t_user")
public List<User> findAll();
}
redis
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
redis:
host: 127.0.0.1
port: 6379
如果有修改端口和访问地址，记得修改，其他默认即可
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
public void testSet() {
//存入数据
redisTemplate.boundValueOps("name").set("zhangsan");
}
@Test
public void testGet() {
//获取数据
Object name = redisTemplate.boundValueOps("name").get();
System.out.println(name);
}
@Test
public void testAll() {
//string 字符串
//redisTemplate.opsForValue().set("str", "heima");
redisTemplate.boundValueOps("str").set("heima");
System.out.println("str = " + redisTemplate.opsForValue().get("str"));
//hash 散列
redisTemplate.boundHashOps("h_key").put("name", "heima");
redisTemplate.boundHashOps("h_key").put("age", 13);
//获取所有域
Set set = redisTemplate.boundHashOps("h_key").keys();
System.out.println(" hash散列的所有域：" + set);
//获取所有值
List list = redisTemplate.boundHashOps("h_key").values();
System.out.println(" hash散列的所有域的值：" + list);
//list 列表
redisTemplate.boundListOps("l_key").leftPush("c");
redisTemplate.boundListOps("l_key").leftPush("b");
redisTemplate.boundListOps("l_key").leftPush("a");
//获取全部元素
list = redisTemplate.boundListOps("l_key").range(0, -1);
System.out.println(" list列表中的所有元素：" + list);
// set 集合
redisTemplate.boundSetOps("s_key").add("a", "b", "c");
set = redisTemplate.boundSetOps("s_key").members();
System.out.println(" set集合中的所有元素：" + set);
// sorted set 有序集合
redisTemplate.boundZSetOps("z_key").add("a", 30);
redisTemplate.boundZSetOps("z_key").add("b", 20);
redisTemplate.boundZSetOps("z_key").add("c", 10);
set = redisTemplate.boundZSetOps("z_key").range(0, -1);
System.out.println(" zset有序集合中的所有元素：" + set);
}
}
MyBatis Plus
<dependencies>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>3.4.0version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starterartifactId>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
application.yml
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://121/plus
username: root
password: root
mapper
package com.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.domain.User;
import org.apache.ibatis.annotations.Mapper;
/**
* Description :
* Version :1.0
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
启动类
package com;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* Description :
* Version :1.0
*/
@SpringBootApplication
@MapperScan("com.mapper")
public class xxxpp {
public static void main(String[] args) {
SpringApplication.run(xxxApp.class,args);
}
}
Test
package com;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.domain.User;
import com.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.sql.Wrapper;
import java.util.List;
/**
* Description :
* Version :1.0
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ybbApp.class)
public class SampleTest {
@Autowired
private UserMapper userMapper;
@Test
public void test1() throws SQLException {
/* System.out.println(dataSource.getConnection());*/
/*List users = userMapper.selectList(null);
for (User user : users) {
System.out.println(user);
}*/
/* userMapper.insert(new User(6,"aa",22,"test6#"));
*
*/
/* QueryWrapper userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("name","aa");
List users = userMapper.selectList(userQueryWrapper);
for (User user : users) {
System.out.println(user);
}*/
UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
userUpdateWrapper.eq("id",1);
userMapper.delete(userUpdateWrapper);
}
}