万字大章学习SpringBoot

科牛

 关注

阅读 108

2022-02-25

文章目录

SpringBoot

​ SpringBoot具有Spring的所有优点，比如开源、轻量级、非侵入式等等。Spring本身具有的控制反转（IOC）和面向切面（AOP）编程也都是SpringBoot的特点。但是Spring本身也有无法避免的缺点，首先就是重量级的配置，各种xml配置文件就像老太太的裹脚布一样，其次项目的依赖管理也是一个老大难得问题，搭建环境时就需要导入大量的库坐标，还需要分析导入与之有关的依赖，一旦出错就会出现各种不兼容的问题。SpringBoot就是针对Spring的缺点进行改善和优化。

SpringBoot的概述

​ SpringBoot是由Privotal团队提供的在Spring框架基础之上开发的框架，其设计目的就是用来简化应用的初始搭建以及开发过程。SpringBoot不是用来替代Spring的解决方案，而是和Spring框架紧密结合用来提升Spring开发者体验的工具，本身并不提供Spring框架的核心特性以及扩展功能。

SpringBoot的特点

  1. 创建独立的Spring应用程序。

  2. 内部直接内嵌tomcat、jetty和undertow服务器。

  3. 提供了固定化的“starter”配置，简化构建配置。

  4. 极大可能的自动配置spring和第三方库。

  5. 提供了产品级的功能，如：安全指标、运行状况检测和外部化配置等。

  6. 绝对不会生成代码，并且不需要xml配置。

SpringBoot的核心功能

  1. 起步依赖

    起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

  2. 自动配置

​ SpringBoot的自动配置是在运行的过程中，考虑了众多的因素，才决定Spring配置应该用哪个，不该用哪个。该过程由Spring自动完成。

SpringBoot环境搭建

​ 不同的开发工具搭建SpringBoot的方法是不一样的，这里我们使用官网配置生成的方式，我们在官网配置好，下载，解压后导入到我们的开发工具即可。

在这里插入图片描述

​ 当我们将解压的项目文件导入到IDE中可以看到项目的结构：
在这里插入图片描述

​ SpringBoot集成web组件后，内置了tomcat服务器，一个SpringBoot应用相当于一个独立的服务，可以使用启动类中的main方法启动SpringBoot程序。
在这里插入图片描述

​ 至此，一个SpringBoot的项目就算是搭建好了。

SpringBoot核心配置文件

​ SpringBoot使用一个全局的配置文件application.properties（文件名是固定的，不可改变），也可以修改格式为application.yml

properties和.yml文件有着不同的语法规则。

applictaion.properties

​ 属性文件的格式，语法结构为键值对的形式。如

#配置内置服务器端口号
server.port = 9898

application.yml

​ yml格式是YAML语言的文件，以数据为中心，以缩进表示逻辑关系，类似于python。如

#配置内置服务器端口号
server:
	port: 9898

yml的基本语法

​ 语法结构 key: (空格) value

​ 表示一对键值对（空格绝对不能省略），以空格的缩进控制层级关系，只要左边对齐的列数据都是同一层级。value值如果为字符串的话默认不用加上双引号或者单引号。如

stu:
	name: 张三
	age: 18
	class: 二班

​ yml文件内容也有许多其它的写法，这里有一些案例：

  1. 普通值
stu:
	name: 张三
	age: 18
	class: 二班

或

stu: {name: 张三,age: 18,class: 二班}
  1. 数组
color:
	-yellow
	-black
	-red

或

color: [yellow,black,red]

SpringBoot的使用

​ SpringBoot是用来简化Spring框架的，因此，不同于Spring的使用方式，SpringBoot有自己的一套使用方式。

SpringBoot注解

​ 注解是框架提供给我们的强大且高效的工具，我们可以通过特定的注解表明我们要进行的特定操作，框架的强大之处就是将本应繁杂的处理代码用一个个小的注解表示起来，让我们可以仅通过一个注解就完成一系列的动作。

@SpringBootApplication
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootDemoApplication {

   public static void main(String[] args) {
      SpringApplication.run(SpringBootDemoApplication.class, args);
   }

}

​ 这个注解是SpringBoot在启动类上，也是SpringBoot最核心的注解，标识这是一个SpringBoot应用，用来开启SpringBoot的各项功能。事实上这个注解是@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个注解的组合。由于三个注解一般都是一起使用，所以SpringBoot提供了这样一个统一注解。

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.annotation.AliasFor;
import org.springframework.data.repository.Repository;

/**
 * Indicates a {@link Configuration configuration} class that declares one or more
 * {@link Bean @Bean} methods and also triggers {@link EnableAutoConfiguration
 * auto-configuration} and {@link ComponentScan component scanning}. This is a convenience
 * annotation that is equivalent to declaring {@code @Configuration},
 * {@code @EnableAutoConfiguration} and {@code @ComponentScan}.
 *
 * @author Phillip Webb
 * @author Stephane Nicoll
 * @author Andy Wilkinson
 * @since 1.2.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

   /**
    * Exclude specific auto-configuration classes such that they will never be applied.
    * @return the classes to exclude
    */
   @AliasFor(annotation = EnableAutoConfiguration.class)
   Class<?>[] exclude() default {};

   /**
    * Exclude specific auto-configuration class names such that they will never be
    * applied.
    * @return the class names to exclude
    * @since 1.3.0
    */
   @AliasFor(annotation = EnableAutoConfiguration.class)
   String[] excludeName() default {};

​ 上面截取的部分代码就是进入@SpringBootApplication注解看到的。

@SpringBootConfiguration

​ 这是SpringBoot中一个类级别的注释，表示此类提供了应用程序级别的配置，通常，具有main（）方法的类最适合此注释。@SpringBootApplication会自动继承这个注解。

@EnableAutoConfiguration

​ 允许SpringBoot自动配置注解，开启这个注解之后，SpringBoot就能根据当前类路径下的包或者类来配置SpringBean。比如，当前类路径下有MyBatis这个jar包，MybatisAutoConfiguration注解就能根据相关参数来参数来配置MyBatis的各个SpringBean。

@ComponentScan

​ 组件扫描注解，让SpringBoot扫描到@Configuration标注的类并把它加入到程序上下文。@ComponentScan注解默认会装配标识了@Controller、@Service、@Respository、@Component注解的类到Spring容器中。

@Configuration

​ 用于定义配置类，指出该类是Bean配置的信息源，相当于传统的xml配置文件，一般加在主类上。如果有些第三方库需要用xml文件，一般仍然通过@Configuration类作为项目的主类。

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.alibaba.druid.pool.DruidDataSource;

//配置德鲁伊数据源
@Configuration
public class DruidDataSourceConfig {

	@Bean
	@ConfigurationProperties(prefix = "spring.datasource")
	public DataSource druid() {
		return new DruidDataSource();
	}
}
@Bean

​ 相当于XML文件中的，放在方法上面，表示方法会返回一个bean，并交给Spring管理。

@ConfigurationProperties

​ 可以将配置文件中的Person属性赋的值映射到该组件中。

  1. 需要先导入相关jar
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
  1. 我们在application配置文件中加入一个新的属性
user1:
	name: jim
	age: 18
  1. 新建一个实体类，并使用标签进行注入
package com.cwd.SpringBootDemo.bean;

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

@Component
@ConfigurationProperties(prefix = "user1")
public class User {

    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

SpringBoot集成JDBC

​ 在我们访问数据库的时候，总是需要先配置一个数据源，数据源是对数据库以及对数据库交互操作的抽象，它封装了目标源的位置信息，验证信息，建立与关闭连接的操作。数据源可以看做程序中一个组件，它把传统中需要在代码里编写配置信息和获取连接等操作抽象出一个规范或者接口。我们以MySQL数据库为例：

  1. 在pom.xml文件中引入MySQL的驱动包
<!-- mysql-connector-java mysql驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>
  1. 在pom.xml文件中引入JDBC支持连接数据库
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
  1. 在application中配置数据源datasource，没有配置其它的数据库源管理，会自动使用JDBC自带的数据库源进行管理，即使用JdbcTemplate操作数据库，这里已经将其交给了Spring进行统一管理，直接使用@Autowired进行注入就可以在类中使用。
#spring配置
#配置数据库，配置数据库源默认使用JDBC自带的数据库源管理
spring:
  datasource:
    #数据库地址
    url: jdbc:mysql://127.0.0.1:3306/mybatis_db?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    #数据库用户名
    username: root
    #数据库密码
    password: root
    #数据库加载类
    driver-class-name: com.mysql.cj.jdbc.Driver
  1. 使用
@Service
@Transactional
public class HelloService {
    @Autowired
    JdbcTemplate jdbcTemplate;

    public User findUserById(Integer id) {
        User user = new User();
        jdbcTemplate.query("select name,age from t_user where  id = ?",
                new Object[]{id}, new RowCallbackHandler() {
                    public void processRow(ResultSet rs) throws SQLException {
                        user.setName(rs.getString("name"));
                        user.setAge(rs.getInt("age"));
                    }
                });
        return user;
    }
}

集成druid(德鲁伊)数据源

​ 当我们使用其它更好的数据源管理时，就不会再使用JDBC自带的数据源管理了。

  1. 导入druid数据源的jar
#spring配置
#配置数据库，配置数据库源默认使用JDBC自带的数据库源管理
spring:
  datasource:
    #数据库地址
    url: jdbc:mysql://127.0.0.1:3306/mybatis_db?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    #数据库用户名
    username: root
    #数据库密码
    password: root
    #数据库加载类
    driver-class-name: com.mysql.cj.jdbc.Driver
    #注册druid数据库链接池
    type: com.alibaba.druid.pool.DruidDataSource
    #初始化时建立物理连接的个数
    initialSize: 5
    #最小连接池个数
    minIdle: 1
    #最大连接池数量
    maxActive: 20
    #开启Sql监控
    filters: stat
  1. 将druid数据源托管给DataSource, 我们需要使用java代码完成这个操作, 相当于我们在xml文件进行如下配置
<!--配置DruidDataSource交给spring容器管理,spring管理数据库链接(数据源)-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis_db?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai"></property>
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.alibaba.druid.pool.DruidDataSource;

//配置德鲁伊数据源
@Configuration
public class DruidDataSourceConfig {

	@Bean
	@ConfigurationProperties(prefix = "spring.datasource")
	public DataSource druid() {
		return new DruidDataSource();
	}
}
SQL监控

​ 使用Sql监控需要在DruidDataSourceConfig类中，即配置druid数据源的类中写入如下代码：

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;


@Configuration
public class DruidDataSourceConfig {

	@Bean
	@ConfigurationProperties(prefix = "spring.datasource")
	public DataSource druid() {
		return new DruidDataSource();
	}

	@Bean
	public ServletRegistrationBean druidStatViewServlet() {
		//ServletRegistrationBean提供类的进行注册
		ServletRegistrationBean servletRegistrationBean =
				new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
		//添加初始化参数：initParams
		//白名单：
		servletRegistrationBean.addInitParameter("allow", "127.0.0.1");
		//IP黑名单（同时存在时，deny优先于allow）
		//如果满足deny，就提示：sorry，you are not permitted to view this page
		servletRegistrationBean.addInitParameter("deny", "192.168.1.73");
		//登录查看信息的账号和密码
		servletRegistrationBean.addInitParameter("loginUsername", "admin");
		servletRegistrationBean.addInitParameter("loginPassword", "123456");
		servletRegistrationBean.addInitParameter("resetEnable", "false");
		return servletRegistrationBean;
	}


	@Bean
	public FilterRegistrationBean druidStatFilter() {
		FilterRegistrationBean filterRegistrationBean =
				new FilterRegistrationBean(new WebStatFilter());
		//添加过滤规则
		filterRegistrationBean.addUrlPatterns("/*");
		//添加需要忽略的格式信息
		filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif," +
				"*.jpg,*.png, *.css,*.ico,/druid/*");
		return filterRegistrationBean;

	}
	 
}

​ 如果我们在创建工程时没有选择集成web，我们还需要在pom.xml文件中进行引入

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

​ 当我们完成这些操作操作之后我们就可以进入http://localhost:端口号/druid/login.html，输入我们在类中的配置的账号（admin）和密码（123456）登录，查看网页中操作数据库的sql记录。

SpringBoot集成MyBatis

  1. 首先我们要在SpringBoot的基础上集成MyBatis的相关jar
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>
  1. 在application文件中配置数据源信息
#MyBtais配置
mybatis:
  type-aliases-package: com.cwd.springboot.bean #开启别名扫描
  mapper-locations: classpath:mapper/*Mapper.xml
  configuration:
    map-underscore-to-camel-case: true #开启驼峰转换
    cache-enabled: true #开启二级缓存

​ 这时我们就可以使用MyBatis了, 一个查询案例 :

​ （1）创建一个t_user表

CREATE TABLE `t_user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(10) DEFAULT NULL,
  `age` int DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8

​ （2）创建一个User的实体类，并加上相关的注解

import org.apache.ibatis.type.Alias;
import org.springframework.stereotype.Component;
import java.util.Date;

@Component
@Alias("User")
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private Date birthday;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}

​ （3）创建查询的dao/mapper接口以及sql映射文件

import com.cwd.SpringBootDemo.bean.User;
import org.springframework.stereotype.Repository;

@Repository
public interface UserDao {
    User findUserById(int id);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- mapper：根元素 namespace:接口存放路径 类路径-->
<mapper namespace="com.cwd.SpringBootDemo.dao.UserDao">

    <select id="findUserById" resultType="com.cwd.SpringBootDemo.bean.User">
        select name,age,birthday from t_user where id = #{id}
    </select>
</mapper>

​ （4）在主类（SpringBoot启动类）上加入一个@MapperScan的注解，它的作用是指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类。

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.cwd.SpringBootDemo.dao")
public class SpringBootDemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringBootDemoApplication.class, args);
	}

}

​ （5）创建调用接口的服务层

import com.cwd.SpringBootDemo.bean.User;
import com.cwd.SpringBootDemo.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
@Transactional/*开启事务管理*/
public class UserService {
    @Autowired
    UserDao userDao;

    public User findUserById(int id) {
        return userDao.findUserById(id);
    }
}

（6）测试

import com.cwd.SpringBootDemo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringBootDemoApplicationTests {

	@Autowired
	UserService userService;

	@Test
	void contextLoads() {
		System.out.println(userService.findUserById(3));
	}

}

日志打印

​ 在application文件中加入日志的配置即可

#日志打印
logging:
  level:
    com.cwd.SpringBootDemo.dao: trace  #等级 只打印操作数据的接口相关日志
  file:
    name: E:\\log\\log.log #日志存放的位置

MyBatis-plus的简单搭建

​ 关于MyBtais-plus的详细学习最好还是依赖官方文档进行MyBatis-plus官网这里我们只完成一个简单的搭建。我们还是使用上面MyBtais的类和表，MyBtais的所有东西都不用动，当然MyBatis-plus是包含了MyBatis的一切的。

  1. 导入MyBatis-plus的相关jar。
<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus-boot-starter</artifactId>
   <version>3.4.1</version>
</dependency>
  1. 用dao接口类继承BaseMapper，泛型是实体类。
@Repository
public interface UserDao extends BaseMapper<User> {

}
  1. 如果要操作的表名和类名不一致，我们需要通过@TableName注解解决
@Component
@Alias("User")
@TableName("t_user")
public class User{
    
}
  1. 调用接口类，MyBatis-plus封装了很多的操作数据库的sql语句，基本都是单张表操作，直接调用即可。
@Service
@Transactional/*开启事务管理*/
public class UserService {
    @Autowired
    UserDao userDao;

    public List<User> findUser() {
        return userDao.selectList(null);
    }
}
  1. 测试
@SpringBootTest
class SpringBootDemoApplicationTests {

	@Autowired
	UserService userService;

	@Test
	void contextLoads() {
		System.out.println(userService.findUser());
	}

}

相关推荐

万字大章学习SpringMVC

玉新行者 90 0 0

万字大章学习MyBatis

梯梯笔记 74 0 0

HTML万字学习总结

言诗把酒 24 0 0

Redis万字大总结，字字珠玑

小龟老师 42 0 0

万字长文带你学习ElasticSearch

奔跑的酆 92 0 0

MyBatis 万字进阶

英乐 91 0 0

万字解析网络套接字

_阿瑶 103 0 0

SpringMVC 万字通关

菜菜捞捞 94 0 0

【面试总结】，万字总结

以前干嘛去了 171 0 0

万字详解OpenDRIVE文件

星河出山 225 0 0

精彩评论（0）

0 0 举报