使用 IDEA 创建 SpringBoot 项目（详细介绍）+ 源码案例实现

使用 IDEA 创建 SpringBoot 项目

• • 一、SpringBoot 案例实现源码
  • 二、SpringBoot 相关配置
  • • 1. 快速创建 SpringBoot 项目
    • • 1.1 新建项目
      • 1.2 填写项目信息
      • 1.3 勾选web依赖包
      • 1.4 构建完成
    • 2. springBoot标准项目结构
    • 3. springboot项目打包部署
    • • 3.1 加载maven插件
      • 3.2 maven命令打包
    • 4. SpringBoot优缺点
    • • 4.1 优点:
      • 4.2 缺点:
    • 5. 修改banner(了解)
    • • 5.1 修改 banner
      • 5.2 关闭 banner
    • 6. 热部署插件(了解)
    • 7. 切换运行环境(了解)
    • 8.SpringBoot参数配置
    • • 8.1 参数来源
      • 8.2 application.properties优先级
    • 9. 参数属性绑定
    • • 9.1 准备工作
      • 9.2 @Value绑定单个属性
      • 9.3 @ConfigurationProperties批量绑定属性
    • 10.系统日志
    • • 10.1 为什么要用日志?
      • 10.2 SpringBoot中的日志介绍
      • 10.3 类中使用日志输出
      • 10.4 Logback配置文件的使用
• 总结

一、SpringBoot 案例实现源码

博客地址：SpringBoot 综合案例源码

二、SpringBoot 相关配置

1. 快速创建 SpringBoot 项目

SpringBoot建议使用官方提供的工具来快速构建项目,网站:https://start.spring.io/ ,IDEA自带该功能,但需要联网使用, 也可以使用 https://start.springboot.io/

注意:官方提供的构建工具默认只能选择固定的版本,有些版本之间的差异非常大,所以如果需要选择某个版本可以自行在pom.xml文件中修改版本

1.1 新建项目

1.2 填写项目信息

根据你需求填写

1.3 勾选web依赖包

1.4 构建完成

2. springBoot标准项目结构

resources：资源文件，存放静态文件，模板文件，配置文件

static：存放静态文件

templates：存放模板文件

application.properties：springboot配置文件

3. springboot项目打包部署

springboot默认将项目打包成jar，然后独立运行

3.1 加载maven插件

<!-- pom.xml中添加插件 -->
<build>
    <plugins>
        <!-- SpringBoot打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

3.2 maven命令打包

1. 通过 maven 运行打包工具
   
2. 打包成功之后，在项目的target包可以找到 jar 包
   
3. 进入target源目录，通过命令行的方式运行 jar（开发过程中我们直接运行启动类就可以了）
   
4. 打开cmd命令框， 运行： java -jar xxx.jar
   
   

注意：如果想修改项目端口， 可以： java -jar xxx.jar --server.port=8888，这里的优先级比在配置文件中的配置的端口号要高

4. SpringBoot优缺点

4.1 优点:

1. 创建独立运行的Spring应用程序
2. 嵌入的Tomcat,无需部署war文件
3. 简化Maven配置
4. 自动配置Spring
5. 提供生产就绪型功能,如:日志,健康检查和外部配置等
6. 不要求配置 XML
7. 非常容易和第三方框架集成起来

4.2 缺点:

1. 版本更新较快,可能出现较大变化

2. 因为约定大于配置,所以经常会出现一些很难解决的问题

5. 修改banner(了解)

5.1 修改 banner

SpringBoot提供了一些扩展点,比如修改banner，
例如：在resources根目录中新建一个 banner.txt 文件,替换默认的banner，txt 内容如下：

                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||_  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
           佛祖保佑        永无BUG
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

5.2 关闭 banner

#application.properties
#关闭banner
spring.main.banner-mode=off

6. 热部署插件(了解)

除了使用JRebel来实现热部署,还可以使用Springboot提供的spring-boot-devtools包来完成Springboot应用热部署

<!-- SpringBoot热部署插件 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

SpringBoot重启是reload重启,通过监控classpath的变化,如果classpath中的文件发生变化,即触发重启.springboot通过两个classpath来完成reload,一个basic classloader中加载不变的类(jar包中的类),一个restart classloader中加载classpath中的类(自己写的类),重启的时候,restart classloader中的类丢弃并重新加载

#默认排除的资源
spring.devtools.restart.exclude=static/**,templates/**,public/**
#增加额外的排除资源
spring.devtools.restart.additional-exclude=public/** #处理默认配置排除之外的
spring.devtools.restart.enabled=false #禁用自动重启

7. 切换运行环境(了解)

在实际开发中,一个系统是有多套运行环境的,如开发时有开发的环境,测试时有测试的环境,不同的环境中,系统的参数设置是不同的,如:连接开发数据和测试数据库的URL绝对是不同的,那么怎么快速的切换系统运行的环境，我们需要为不同的环境创建不同的配置文件。

• application-dev.properties

server.port=8081

• application-test.properties

server.port=8082

• 在application.properties中指定需要使用的环境即可

#指定使用的环境是dev
spring.profiles.active=dev

8.SpringBoot参数配置

8.1 参数来源

主要流程摘要：
1，命令行参数； 如: java -jar xxx.jar --server.port=80
2，ServletConfig和ServletContext；
3，操作系统环境变量；
4，application-{profile}.properties或者YAML文件；
5，application.properties或者YAML文件；

一般用的比较多的就是直接在application.properties或者YAML配置 , 其次是命令行启动方式

application.properties语法

server.port=80
server.session-timeout=30
server.tomcat.uri-encoding=UTF-8  

spring.datasource.url = jdbc:mysql://localhost:3306/crm
spring.datasource.username = root
spring.datasource.password = mymysql
spring.datasource.driverClassName = com.mysql.jdbc.Driver

vs

application.yml语法

server:
  port: 80
  session-timeout: 30
  tomcat.uri-encoding: UTF-8  

spring:
  datasource:
    url : jdbc:mysql://localhost:3306/crm
    username : root
    password : mymysql
    driverClassName : com.mysql.jdbc.Driver

8.2 application.properties优先级

一个项目中可以有多个application.properties文件存放在不同目录中,此时他们会遵循固定的优先级来处理有冲突的属性配置, 优先级由高到底，高优先级的配置会覆盖低优先级的配置

1. 项目/config/application.properties
2. 项目/application.properties
3. classpath:config/application.properties
4. classpath:application.properties

注意：一般都在classpath:application.properties做配置,其他方式不使用

9. 参数属性绑定

9.1 准备工作

#application.properties
jdbc.username=root
jdbc.password=admin

9.2 @Value绑定单个属性

@Controller
public class HelloController {
    @Value("${jdbc.username}")
    private String username;

    @RequestMapping("/hello")
    @ResponseBody
    public Object hello(){
        return "hello, springboot~" + username;
    }
}

直接访问/hello观察username值，也可以在自定义的类上绑定， 注意前提是这个类必须交给spring容器管理

@Component
@ToString
@Setter
@Getter
public class MyData {
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

}

注入MyDataSource 测试value是否能取值

@Autowired
private MyData myData;

@RequestMapping("/value")
@ResponseBody
public Object value(){
    return myData;
}

9.3 @ConfigurationProperties批量绑定属性

若觉得上面的方式比较笨重, 可以把前缀抽取到@ConfigurationProperties中, 并且设置类属性与需要绑定的参数名相同, 可实现自动绑定 ,

自定义类

@Component
@ToString
@Setter
@Getter
@ConfigurationProperties("jdbc")  //相当于 @ConfigurationProperties(prefix="jdbc")
public class MyData {
    private String username;
    private String password;
}

或者在配置类中加入如下代码：

/**
 * 获取到 application.properties 中对应前缀为 jdbc. 后面的属性名（username、password）
 * 并把属性名对应的值设置到 MyData 对应的成员变量上，然后创建实例并交给 Spring 容器管理
 */
@Bean
@ConfigurationProperties("jdbc")
public MyData myData() {
    return new MyData();
}

10.系统日志

10.1 为什么要用日志?

1. 比起System.out.println,日志框架更为灵活,可以把日志的输出和代码分离
2. 日志框架可以方便的定义日志的输出环境,控制台,文件,数据库
3. 日志框架可以方便的定义日志的输出格式和输出级别

10.2 SpringBoot中的日志介绍

1. Springboot默认已经开启日志
   默认的日志格式为: 时间 日志级别 线程ID 线程名称 日志类 日志说明；

2. Springboot的日志分为: 系统日志和应用日志；

3. 日志级别,设置的级别越高,输出的内容越少, 如果设置的级别为info, 则debug以及trace级别的都无法显示
   trace < debug < info < warn < error；

4. Springboot默认选择Logback作为日志框架,也能选择其他日志框架,但是没有必要
   common-logging / java-logging / log4j / log4j2 / logback / slf4j；

5. SpringBoot 默认日志级别是 info，因为 debug、trace 低于 info 级别，所以不会显示，除非主动配置；

10.3 类中使用日志输出

在我们自定义的类中如果要使用日志框架来输出
方式1: 在类中定义一个静态Logger对象
这里传入当前类的作用是方便输出日志时可以清晰地看到该日志信息是属于哪个类的（导入的包是 org.slf4j）

private static final Logger log = LoggerFactory.getLogger(当前类.class);

方式2: 使用lombok提供的@Slf4j注解来简化代码 , 其实和方式1的作用是一样的

@Slf4j
@Service
public class PermissionServiceImpl implements IPermissionService {}

在需要输出日志的地方使用日志的输出方法

log.info(...);
log.error(...);
...
//输出日志中有变量可以使用{}作为占位符
log.info("删除id为{}的数据", id);

如果要修改日志级别,最快速的方式是在application.properties配置

#把日志级别修改为debug,不过我们一般不会更改,除非要调试找bug,不然控制台显示的内容太多也容易乱
logging.level.root=debug

10.4 Logback配置文件的使用

Logback框架默认会自动加载classpath:logback.xml,作为框架的配置文件,在SpringBoot中使用时,还会额外的支持自动加载classpath:logback-spring.xml,在SpringBoot中推荐使用logback-spring.xml,功能更强大些

样板文件:

<?xml version="1.0" encoding="UTF-8"?>
<!--
    scan:开启日志框架的热部署,默认值true表示开启
    scanPeriod:热部署的频率,默认值60 second
    debug:设置输出框架内部的日志,默认值false
-->
<configuration scan="true" scanPeriod="60 second" debug="false">
    <property name="appName" value="springboot demo" />
    <contextName>${appName}</contextName>

    <!-- appender:日志输出对象,配置不同的类拥有不同的功能
        ch.qos.logback.core.ConsoleAppender:日志输出到控制台
    -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd-HH:mm:ss} %level [%thread]-%logger{35} >> %msg %n</pattern>
　　　　　</encoder>
　　 </appender>

    <!-- ch.qos.logback.core.FileAppender:日志输出到文件中
    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <encoder>
            <pattern>%-4relative [%thread] %level %logger{35} - %msg %n</pattern>
    　　 </encoder>
        <append>true</append>
        <file>mylog.log</file>
　　 </appender>
    -->

    <!-- root是项目通用的logger,一般情况下都是使用root配置的日志输出
        level:按照级别输出日志,日志级别,级别越高,输出的内容越少
            trace < debug < info < warn < error
    -->
　　 <root level="info">
        <appender-ref ref="STDOUT" />
    </root>

    <!-- 自定义的logger,用于专门输出特定包中打印的日志
    <logger name="cn.wolfcode.crm.mapper" level="trace">
    </logger>
	-->
</configuration>

参考日志格式:

• %d{yyyy-MM-dd-HH:mm:ss} %level [%thread]-%class:%line >> %msg %n

格式中的标识符组成:

• %logger{n}: 输出Logger对象类名,n代表长度

• %class{n}: 输出所在类名，

• %d{pattern}或者date{pattern}: 输出日志日期,格式同java

• %L/line: 日志所在行号

• %m/msg: 日志内容

• %method: 所在方法名称

• %p/level: 日志级别

• %thread: 所在线程名称

总结

以上就是 SpringBoot 基本配置的介绍了，代码仅供参考，欢迎讨论交流。
SpringBoot 项目入门请看我上一篇博客，博客地址：SpringBoot快速入门（解析+入门案例源码实现）