springboot核心学习

最新推荐文章于 2023-10-23 07:54:59 发布

林尽处听雨眠

最新推荐文章于 2023-10-23 07:54:59 发布

阅读量269

点赞数

文章标签： springboot

一、Springboot概述

SpringBoot自然是在Spring的基础上产生的（确切的说是Spring4.0版本的基础上），其中“Boot”的意思就是“引导”（不是靴子^_^），意在简化开发模式，使开发者快速开发出基于Spring的应用。
SpringBoot并不是Spring官方的框架模式，而是由Pivotal团队二次开发并开源提供。它的设计目的就是为了简化Spring应用的初始搭建以及开发过程。SpringBoot的出现使得开发人员不再拘于繁琐的模板化的配置，可以快速搭建应用。
要注意的是，SpringBoot不是一个新的框架，而是在Spring框架的基础上做了大量的优化。其可以自动配置Spring，简化Maven配置，整合常用依赖，可自动嵌入中间件插件（Tomcat/Jboss/jetty）提供应用状态（指标，健康检查和外部配置），无代码生成和xml配置等。

二、Springboot基本配置

1、入口类和@SpringBootApplication

Spring Boot通常有一个名为*Application的入口类，入口类里面有一个main方法，这个main方法其实就是一个标准的Java应用的入口。在main方法中使用SpringApplication.run(HelloApplication.class, args)，启动Spring Boot应用项目。

@SpringBootApplication是Spring Boot的核心注解，它是一个组合注解,SpringBootApplication源码如下：

@Target({java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented@Inherited@Configuration
@EnableAutoConfiguration@ComponentScan
public @interface SpringBootApplication{
  public abstract Class<?>[] exclude();

  public abstract String[] excludeName();
}

@SpringBootApplication注解主要组合了@Configuration，@EnableAutoConfiguration，@ComponentScan；若不使用@SpringBootApplication注解，则可以在入口类上直接使用@Configuration，@EnableAutoConfiguration，@ComponentScan三个注解的效果是一样的。
其中@EnableAutoConfiguration让Spring Boot根据类路径中的jar包依赖为当前项目进行自动配置。

例如，添加了spring-boot-starter-web依赖，会自动添加Tomcat和Spring MVC的依赖，那么Spring Boot会对Tomcat和Spring MVC进行自动配置。

又如，添加了spring-boot-starter-jpa依赖,Spring Boot会自动进行JPA相关的配置。

Spring Boot会自动扫描@SpringBootApplication所在类的同级包(如org.light4j.springboot.config)以及下级包里面的Bean(若为JPA项目还可以扫描标注@Entity的实体类)。建议入口类放置在groupId+arctifactID组合的包名下。

2、关闭特定的自动配置

要关闭Spring Boot对数据源的自动配置，则可以这样使用，例如：

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})

3、定制Banner

在Spring Boot启动的时候会有一个默认启动方案，如下图所示：

如果想把这个图案修改成自己的，步骤如下所示：

(1). 在src/main/resources下新建一个banner.txt。
(2). 通过http://patorjk.com/software/taag网站生成字符，如敲入的为"LONGJIAZUO",将网站生成的字符复制到banner.txt中。
(3). 这时再启动程序，图案将变为如下图所示：

 
\/____//'/\ \ \___      __      ___      __     ____  _____
     //'/' \ \  _ `\  /'__`\  /' _ `\  /'_ `\  /',__\/\ '__`\
    //'/'___\ \ \ \ \/\ \L\.\_/\ \/\ \/\ \L\ \/\__, `\ \ \L\ \
    /\_______\ \_\ \_\ \__/.\_\ \_\ \_\ \____ \/\____/\ \ ,__/
    \/_______/\/_/\/_/\/__/\/_/\/_/\/_/\/___L\ \/___/  \ \ \/
                                         /\____/        \ \_\

关闭banner

入口类mian方法内容修改为：

SpringApplication application = new SpringApplication(HelloApplication.class);application.setBannerMode(Banner.Mode.OFF);application.run(args);or使用fluent API修改为：

new SpringApplicationBuilder(HelloApplication.class).bannerMode(Banner.Mode.OFF).run(args);

三、Springboot配置文件

Spring Boot的全局配置文件的作用是对一些默认配置的配置值进行修改。Spring Boot使用一个全局的配置文件application.properties或application.yml进行全局配置，放置在src/main/resources目录或者类路径的/config下。

Spring Boot不仅支持常规的properties配置文件，还支持yaml语言的配置文件。yaml是以数据为中心的语言，在配置数据的时候具有面向对象的特征。

简单示例：

将Tomcat的默认端口号修改为9090，并将默认的访问路径”/”修改为”/springboot_configFile“，可以在application.properties中添加：

server.port=9090server.context-path=/springboot_configFile

四、Springboot的XML配置

Spring Boot提倡零配置，即无xml配置，但是在实际项目中，可能有一些特殊要求你必须使用xml配置，这时候可以通过在配置类上面使用Spring提供的@ImportResource来在加载xml配置，例如：

@ImportResource(value = { "classpath:some-context.xml","classpath:another-context.xml" })

步骤：

1. 新建包

新建两个包:org.light4j.springboot.xml.scan和org.light4j.springboot.xml.noScan

2. 新建启动类

新建Application.java启动类，放到包org.light4j.springboot.xml.scan下，根据Spring Boot的扫描原则（扫描从根包到子包的原则），能够扫描到org.light4j.springboot.xml.scan以及它的子包，org.light4j.springboot.xml.noScan包以及子包则不能被扫描到，代码如下：

package org.light4j.springboot.xml.scan;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.ImportResource;@SpringBootApplicationpublic class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }}

3. 新建Service类

新建ScanService和NoScanService两个Service类，根据Spring Boot的扫描原则，我们把ScanService写在Spring Boot可以扫描的位置,也即放到包org.light4j.springboot.xml.scan下，NoScanService写在SpringBoot无法扫描到的位置,也即放到包org.light4j.springboot.xml.noScan下。
ScanService.java代码如下所示：

package org.light4j.springboot.xml.scan;import org.springframework.stereotype.Service;@Servicepublic class ScanService {
    public ScanService() {
        System.out.println("I am ScanService,i can be scan");
    }}

NoScanService.java代码如下所示：

package org.light4j.springboot.xml.noScan;import org.springframework.stereotype.Service;@Servicepublic class NoScanService {
    public NoScanService() {
        System.out.println("I am NoScanService,i can not be scan");
    }}

4. 运行程序

运行Application.java，看到控制台打印日志如下图所示：

从上面可以看到，在程序启动的时候，执行了ScanService类的构造函数，而NoScanService没有执行，这是因为NoScanService所在的包没有被扫描到，所以没有进行初始化。那么下面我们使用xml配置文件的方式进行引入。

5. 编写application-bean.xml

在src/main/resouces目录下编写配置文件application-bean.xml文件，内容如下所示：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 注入spring boot无法扫描到的bean. -->
    <bean id="noScanService" class="org.light4j.springboot.xml.noScan.NoScanService"></bean></beans>

6. 导入配置文件

在启动类Application上使用注解@ImportResource(value = { "classpath:application-bean.xml" })导入bean的配置文件，修改后的Application启动类如下图所示：

package org.light4j.springboot.xml.scan;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.ImportResource;@SpringBootApplication@ImportResource(value = { "classpath:application-bean.xml" })public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }}

7.运行程序测试

从上面可以看到，在程序启动的时候，ScanService和NoScanService的构造函数都被执行了，二者构造函数里的代码都在控制台打印。

五、Springboot日志配置

Spring Boot支持Java Util Logging，Log4J,Log4J2和Logback作为日志框架，无论使用哪种日志框架，SpringBoot已经为当前使用的日志框架在控制台的输出以及在文件的输出做好了配置。

默认情况下，Spring Boot使用Logback作为日志框架。

示例

1. 配置日志文件，格式为logging.file=文件路径：

logging.file=F:/mylog/log.log

2. 配置日志级别，格式为logging.level.包名=级别，如下所示：

logging.level.org.springframework.web = DEBU

运行后如下：

六、Springboot的AOP

AOP是Spring框架中的一个重要内容，在Spring boot里配置aop非常简单，Spring Boot对AOP的默认配置属性是开启的，也就是说spring.aop.auto属性的值默认是true，我们只要引入了AOP依赖后，默认就已经增加了@EnableAspectJAutoProxy功能，不需要我们在程序启动类上面加入注解@EnableAspectJAutoProxy。

下面将使用Spring Boot通过模拟记录操作日志来演示基于注解拦截的AOP实现方式。

示例

1. 添加依赖

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

2. 编写拦截规则的注解

package org.light4j.springboot.aop.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target({ ElementType.PARAMETER, ElementType.METHOD })@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Action {

    String value() default "";}

(3). 在控制器的方法上使用注解@Action

package org.light4j.springboot.aop.controller;import org.light4j.springboot.aop.annotation.Action;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HelloController {

    @RequestMapping("/")
    @Action("hello")
    public String hello() {
        return "Hello Spring Boot";
    }}

(4). 编写切面

package org.light4j.springboot.aop.aspect;import java.lang.reflect.Method;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;import org.aspectj.lang.reflect.MethodSignature;import org.light4j.springboot.aop.annotation.Action;import org.springframework.stereotype.Component;@Aspect@Componentpublic class LogAspect {

    // pointCut
    @Pointcut("@annotation(org.light4j.springboot.aop.annotation.Action)")
    public void log() {

    }

    /**
     * 前置通知
     */
    @Before("log()")
    public void doBeforeController(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Action action = method.getAnnotation(Action.class);
        System.out.println("action名称 " + action.value()); // ⑤
    }

    /**
     * 后置通知
     */
    @AfterReturning(pointcut = "log()", returning = "retValue")
    public void doAfterController(JoinPoint joinPoint, Object retValue) {
        System.out.println("retValue is:" + retValue);
    }}