目录
一、SpringBoot功能
二、SpringBoot快速入门
导入父工程：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.1</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>导入JavaWeb起步依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>定义Controller：
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello Spring Boot 2";
}
}编写引导类：
package com.itheima.springbootinit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringbootInitApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootInitApplication.class, args);
}
}
三、SpringBoot起步依赖原理分析
四、SpringBoot配置
4.1 配置文件分类
4.2 yaml
4.3 yml数据格式
4.4 读取配置内容
1）直接定义对应的属性即可获取
@Value("${name}")
private String name;2）获取：env.getProperty("person.name")
@Autowired
private Environment env;3）实体类中配置：
@Component
@ConfigurationProperties(prefix = "person")//前缀person
获取：
person.getAddress();4.5 profile
4.6 内部配置加载顺序
4.7 外部配置的加载顺序
- 外部配置文件优先
- 带config文件的优先
五、SpringBoot整合其它框架
5.1 SpringBoot整合Junit
测试类：
/**
* userService的测试类
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootTestApplication.class)
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
public void testAdd(){
userService.add();
}
}
若果是同样的包名，则在SpringBootTest注解中不用加小括号里的内容
/**
* userService的测试类
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
public void testAdd(){
userService.add();
}
}
5.2 SpringBoot整合Redis
待续.....
5.3 SpringBoot整合Mybatis
①注解开发：
实体类：
package com.itheima.springbootmybatis.domain;
public class User {
private int id;
private String username;
private String password;
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + 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;
}
}
配置信息（application.yml）：
#datasource数据源信息
spring:
datasource:
url: jdbc:mysql:///springboot #"///"默认本地的Mysql
username: root
password: 'xxxx' #密码要用单括号括起来
driver-class-name: com.mysql.cj.jdbc.Driver接口：
@Mapper
public interface UserMapper {
@Select("select * from t_user")
public List<User> finAll();
}
测试类：
@SpringBootTest
class SpringbootMybatisApplicationTests {
@Autowired
private UserMapper userMapper;
@Test
public void testFindAll() {
List<User> users = userMapper.finAll();
System.out.println(users);
}
②XML配置：
实体类：
package com.itheima.springbootmybatis.domain;
public class User {
private int id;
private String username;
private String password;
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + 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;
}
}
配置信息（application.yml）：
#datasource数据源信息
spring:
datasource:
url: jdbc:mysql:///springboot #"///"默认本地的Mysql
username: root
password: 'xxx' #密码要用单括号括起来
driver-class-name: com.mysql.cj.jdbc.Driver
#mybatis
mybatis:
mapper-locations: classpath:mapper/*Mapper.xml # mapper的映射文件路径
type-aliases-package: com.itheima.springbootmybatis.domain # 别名，User类所在包名
# config-location: 指定mybatis的核心配置文件
接口：
@Mapper
public interface UserXmlMapper {
public List<User> findAll();
}mapper.xml映射文件：
namespace指定映射关系，映射到哪一个类/接口，需要用到全类名
<mapper namespace="com.itheima.springbootmybatis.mapper.UserXmlMapper">
<select id="findAll" resultType="user">
select * from t_user
</select>
</mapper>测试类：
@SpringBootTest
class SpringbootMybatisApplicationTests {
@Autowired
private UserMapper userXmlMapper;
@Test
public void testFindAll() {
List<User> users = userXmlMapper.finAll();
System.out.println(users);
}
}六、 Springboot自动配置
6.1 Condition
Condition是在Spring4.0增加的条件判断功能，通过这个可以选择性的实现选择性的创建Bean操作。
ClassCondition类：
package com.itheima.springbootcondition.condition;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import redis.clients.jedis.Jedis;
//继承条件接口
public class ClassCondition implements Condition{
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//1.需求：导入Jedis坐标后创建Bean
//思路：判断redis.clients.jedis.Jedis.class文件是否存在
boolean flag = true;
try {
Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
} catch (ClassNotFoundException e) {
flag = false;
}
return flag;//决定了是否创建对应的Bean，在UserConfig需要结合注解Conditional使用
}
}
UserConfig类：
@Configuration
public class UserConfig {
@Bean
@Conditional(ClassCondition.class)
public User user(){
return new User();
}
}引导类：
@SpringBootApplication
public class SpringbootConditionApplication {
public static void main(String[] args) {
//启动SpringBoot的应用，返回Spring的IOC容器
ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
/*
//获取Bean，RedisTemplate
Object redisTemplate = context.getBean("redisTemplate");
System.out.println(redisTemplate);*/
Object user = context.getBean("user");
System.out.println(user);
}
自定义注解：
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
String[]value();
}ClassCondition类：
//继承条件接口
public class ClassCondition implements Condition{
/**
*
* @param context 上下文对象。用于获取环境，IOC容器，classLoader对象
* @param metadata 注解原元对象。可以用于获取注解定义的属性值
* @return
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//2.需求：导入通过注解属性值value指定坐标后创建Bean
//获取注解属性值 value
Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
String[] value = (String[]) map.get("value");
boolean flag = true;
try {
for (String className : value) {
Class<?> cls = Class.forName(className);
}
} catch (ClassNotFoundException e) {
flag = false;
}
return flag;//决定了是否创建对应的Bean，在UserConfig需要结合注解Conditional使用
}
}UserConfig使用自定义注解：
@Configuration
public class UserConfig {
@Bean
//@Conditional(ClassCondition.class)
@ConditionOnClass("redis.clients.jedis.Jedis")//可以自定义
public User user(){
return new User();
}
}启动类：
@SpringBootApplication
public class SpringbootConditionApplication {
public static void main(String[] args) {
//启动SpringBoot的应用，返回Spring的IOC容器
ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
Object user = context.getBean("user");
System.out.println(user);
}
}
6.2 切换内置服务器
pom文件中：排除tomcat服务器，引入jetty服务器
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!--排除tomcat的依赖。shift + delete-->
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>
<!--引入jetty的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>6.3 Enable*注解
package com.itheima.springbootenableother;
import com.itheima.config.EnableUser;
import com.itheima.config.UserConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
/**
* @ComponentScan 扫描范围是当前引导类所在及其子包
* com.itheima.springbootenableother
* com.itheima.config
* //1.使用@ComponentScan扫描com.itheima.config包
* //2.可以使用@Import注解加载类。这些类都会被Spring创建，并放入IOC容器
* //3.可以对@Import注解进行封装
*/
@SpringBootApplication
//@ComponentScan("com.itheima.config")
//@Import(UserConfig.class)
@EnableUser
public class SpringbootEnableOtherApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableOtherApplication.class, args);
//获取Bean
Object user = context.getBean("user");
System.out.println(user);
}
}
对@Import进行封装：
package com.itheima.config;
import org.springframework.context.annotation.Import;
import java.lang.annotation.*;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}
6.4 Import注解
@Import的4种用法 * 1.导入Bean * 2.导入配置类,config类中可以不加@COnfiguration注解 * 3.导入ImportSelector的实现类 * 4.导入ImportBeanDefinitionRegistrar实现类
1. 导入Bean
@SpringBootApplication
@Import(User.class)
public class SpringbootEnableOtherApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableOtherApplication.class, args);
User user = context.getBean(User.class);
System.out.println(user);
Map<String, User> map = context.getBeansOfType(User.class);
System.out.println(map);
}
}
2.导入配置类，Config类中可以不适用Configuration
public class UserConfig {
@Bean
public User user(){
return new User();
}
@Bean
public Role role(){
return new Role();
}
}
@SpringBootApplication
@Import(UserConfig.class)
public class SpringbootEnableOtherApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableOtherApplication.class, args);
User user = context.getBean(User.class);
System.out.println(user);
Role role = context.getBean(Role.class);
System.out.println(role);
}
}
3.导入ImporSelector实现类
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.itheima.domain.User","com.itheima.domain.Role"};
}
}@SpringBootApplication
@Import(MyImportSelector.class)
public class SpringbootEnableOtherApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableOtherApplication.class, args);
User user = context.getBean(User.class);
System.out.println(user);
Role role = context.getBean(Role.class);
System.out.println(role);
}
}
4.导入ImportBeanDefinitionRegistrar实现类
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
registry.registerBeanDefinition("user", beanDefinition);
}
}@SpringBootApplication
@Import(MyImportBeanDefinitionRegistrar.class)
public class SpringbootEnableOtherApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableOtherApplication.class, args);
User user = context.getBean(User.class);
System.out.println(user);
Role role = context.getBean(Role.class);
System.out.println(role);
}
}
6.5 EnableAutoConfiguration注解
6.6 自定义starter步骤分析
RedisProperties：
@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
private String host = "localhost";
private int port = 6379;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
}RedisAutoConfig：
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
@ConditionalOnClass(Jedis.class)//有Jedis时才加载
public class RedisAutoConfig {
/**
* 提供Jedis的Bean
*/
@Bean
@ConditionalOnMissingBean(name = "jedis")//如果没有jedis时才提供此方法来提供jedis Bean
public Jedis jedis(RedisProperties redisProperties){
System.out.println("RedisAutoConfig");
return new Jedis(redisProperties.getHost(),redisProperties.getPort());
}
}在resource下创建一个名为“META-INF”的File，并在其下创建“spring.factories”
在“spring.factories”中：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.itheima.redis.config.RedisAutoConfig在自动配置（autoconfigure）模块的pom文件中引入
<!--引入Jedis依赖-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>在starter模块中的pom文件中引入
<!--引入Configure-->
<dependency>
<groupId>com.itheima</groupId>
<artifactId>redis-spring-boot-autoconfigure</artifactId>
<version>0.0.1-SNAPSHOT</version>在自定义类中若要使用自定义的起步依赖，需要在自己的pom文件中导入自定义的起步依赖的坐标后方可使用
<!--自定义的redis的starter-->
<dependency>
<groupId>com.itheima</groupId>
<artifactId>redis-spring-boot-starter</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>七、SpringBoot监听机制
@Component
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("ApplicationContextInitializer...initialize");
}
}public class MySpringApplicationRunListener implements SpringApplicationRunListener {
public MySpringApplicationRunListener(SpringApplication application, String[] args) {
}
public void starting() {
System.out.println("staring...项目启动中");
}
public void environmentPrepared(ConfigurableEnvironment environment) {
System.out.println("environmentPrepared...环境对象开始准备");
}
public void contextPrepared(ConfigurableApplicationContext context) {
System.out.println("contextPrepared...上下文对象开始准备");
}
public void contextLoaded(ConfigurableApplicationContext context) {
System.out.println("contextLoaded...上下对象开始加载");
}
public void started(ConfigurableApplicationContext context) {
System.out.println("started...上下文对象加载完成");
this.started(context);
}
public void running(ConfigurableApplicationContext context) {
System.out.println("running...项目启动完成，开始运行");
}
public void failed(ConfigurableApplicationContext context, Throwable exception) {
System.out.println("failed...项目启动失败");
}
}
/**
* 当项目启动后自动执行run方法
*/
@Component
public class MyApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner...run");
System.out.println(Arrays.asList(args.getSourceArgs()));
}
}@Component
public class MyCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner...run");
System.out.println(Arrays.asList(args));
}
}
在Resource下建立META-INF文件，建立spring.factories,并在其中配置
org.springframework.context.ApplicationContextInitializer=
com.itheima.springbootlistener.listener.MyApplicationContextInitializer
org.springframework.boot.ConfigurableBootstrapContext=
com.itheima.springbootlistener.listener.MySpringApplicationRunListener八、SpringBoot启动流程分析
九、SpringBoot监控
十、SpringBoot项目部署
Jar包(内置tomcat)：Maven工具打包即可（默认方式）
打开方式：在相应文件所在位置,"shift+鼠标右键"用powershell打开即可
在浏览器中输入对应的url即可访问
War包(外置tomcat)：pom文件中指定打为war包
<packaging>war</packaging>引导类继承SpringBootServletInitializer：
@SpringBootApplication
public class SpringbootDeployApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(SpringbootDeployApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringbootDeployApplication.class);
}
}@RequestMapping("/user")
@RestController
public class UserController {
@RequestMapping("/findAll")
public String findAll(){
return "success";
}
}打开方式： 将war包拖拽到tomcat文件内，启动tomcat(startup.bat)
注意在游览器内输入相应的url时需要在localhost:端口号\springboot\对应url