SpringBoot

后端 springboot

发布时间 : 2024-08-29 19:24

字数:2.2k 阅读 :

SpringBoot

Springboot多模块

1.项目的基本结构

其中
blog-core 是核心模块
blog-tool 是工具模块
blog-api 是前端项目
blog-admin 是后台项目

首先父pom文件

    <groupId>com.yf</groupId>
    <artifactId>zfanblog</artifactId>
    <version>Z-0.0.1</version>
    <name>zfanblog</name>
    <packaging>pom</packaging><!-- 注意：修改jar为pom -->
    <description>zfan.top blog</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <!--引入子模块-->
     <modules>
        <module>blog-core</module>
        <module>blog-api</module>
        <module>blog-admin-api-82</module>
    </modules>
    <!--项目依赖，子pom文件会继承父pom的依赖-->
    <dependencies>
        ...
    </dependencies>

** 在Springboot 多模块项目中，不要在父pom文件和其他没有启动类的项目中配置 build 标签。只在需要的子项目的pom文件中配置（一般是web项目）**

在blog-core中的pom文件

  <!-- 过滤xml文件-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>

            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**.*</include>
                    <include>**/*.*</include><!-- i18n能读取到 -->
                    <include>**/*/*.*</include>
                </includes>
                <filtering>false</filtering>
            </resource>

所有的子模块中pom 父依赖改为如下

在可以启动的web模块的pom文件中都打包成war包,核心模块打包成jar就可

<parent>
    <groupId>com.yf</groupId>
    <artifactId>zfanblog</artifactId>
    <version>Z-0.0.1</version>
</parent>

<plugin>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal><!--可以把依赖的包都打包到生成的Jar包中-->
            </goals>
        </execution>
    </executions>
</plugin>

 <!--在war包的pom文件中需要移除tomcat-->
 <!-- tomcat 部署需要-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-tomcat</artifactId>
     <scope>provided</scope>
</dependency>

springboot多模块包扫描问题

需要在启动模块的application启动类中加入

一个为依赖的核心模块的包,一个为本模块的包
scanBasePackages属性显示指定要扫描的包的范围。
@SpringBootApplication(scanBasePackages = { "com.yf.blogcore","com.yf.blogapi" })）

扫描的mapper文件
@MapperScan({"com.yf.blogcore.mapper","com.yf.blogcore.mapper.xml"})

2.spring boot 用 spring.profiles.active来解决多个profile的问题

spring.profiles.active=core

这个 core是核心模块中的 application-core.properties , spring.profiles.active只需application-后边的值

c76d26b1-2b9e-41d7-996e-57a7fe765f2f

到这里你就可以启动成功了…可以部署tomcat中

springboot自定义starter

定义一个自己需要的starter，想实现做一个工具类的starter，方便自己使用

1. 首先创建一个springboot项目，

官方命名：
spring-boot-starter-XXX
spring-boot-starter-jdbc

非官方命名：
XXX-spring-boot-starter
mybatis-spring-boot-starter

一个完整的SpringBootStarter通常包含autoconfigure和starter两个模块，
当然也可以将他们全都合并到starter模块中。

2. pom.xml依赖，

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.yf</groupId>
    <artifactId>ztools-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ztools-spring-boot-starter</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
    <!-- Spring Boot自身的自动配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>
    <!-- 提供一种自动生成spring-configuration-metadata.json的依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    
</project>

3. 编写一个配置参数类，

这里设置了我们自定义starter中需要用到的配置，我们可以将其设置一个默认的值。比如redis的starter中的端口配置、连接池配置等。通过ConfigurationProperties注解，我们将properties或者yml文件中符合前缀的参数绑定到这个类的属性上

package com.yf.ztoolspringbootstarter;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "zfan")
public class HelloProperties {
    /**
     * 打招呼的内容，默认为“World!”
     */
    private String msg = "World!";
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

这里属性的值我们可以在application.properties或者yml中来直接设置

zfan.msg=hello

4. 创建一个业务类，

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class HelloService {
    @Autowired
    private HelloProperties helloProperties;
    /**
     * 打招呼方法
     *
     * @param name 人名，向谁打招呼使用
     * @return
     */
    public String sayHello(String name) {
        return "Hello " + name + " " + helloProperties.getMsg();
    }
}

5. 创建一个自动配置类，

import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//定义为配置类
@Configuration
//在web工程条件下成立
@ConditionalOnWebApplication
//启用HelloProperties配置功能，并加入到IOC容器中
@EnableConfigurationProperties({HelloProperties.class})
//导入HelloService组件
@Import(HelloService.class)
//@ComponentScan
public class HelloAutoConfiguration {
}

6. 如果想自动配置生效

在resources下创建文件夹META-INF然后创建spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.yf.ztoolspringbootstarter.HelloAutoConfiguration

注意
删除 resources 下的其他文件
删除 springbootde 启动类
删除spring-boot-starter-test依赖并且删除test目录。

7. mvn clean install 若mvn是外部命令，在环境变量中添加maven中bin目录的配置

8. 创建一个Spring Boot项目，pom中引入ztools-spring-boot-starter依赖

9. 测试

添加包扫描 否则 @Autowired 引入报错
@SpringBootApplication(scanBasePackages = { "com.yf.ztoolspringbootstarter"})

    @Autowired
    private HelloService helloService;

    @RequestMapping(value = "/sayHello")
    @ResponseBody
    public String sayHello(String name){
        System.out.println(helloService.sayHello(name));
        return helloService.sayHello(name);
    }

spring-boot-configuration-processor 可以提供生成可以一种spring-configuration-metadata.json
然后就可以在 application.properties 中有提示

zfan.msg=你好

816c8546-29e2-4083-b642-397d8786624e

Spring Factories

我们得一些SDK或者Spring Boot Starter要给被人使用时，我们就可以使用Factories机制。Factories机制可以让SDK或者Starter的使用只需要很少或者不需要进

行配置，只需要在服务中引入我们的jar包即可

只需如下配置，在第三方项目中引入后无需就行配置扫描bean

org.springframework.boot.autoconfigure.EnableAutoConfiguration = com.v0710.docommon.DoCommonSDKAutoConfiguration

AOP使用

1，通知方法

前置通知（@Before）
后置通知（@After）
返回通知（@AfterReturning）
异常通知（@AfterThrowing）
环绕通知（@Around）
@Aspect ：指定切面类
@PointCut：公共切入点表达式
JoinPoint：作为函数的参数传入切面方法，可以得到目标方法的相关信息

2，简单使用

普通的切面

@Configuration
@Aspect
public class UserInfoAspect {
    @Pointcut("execution(* com.*.test(*))")
    public void test() {}
    @AfterReturning(value = "test()"")
    public void logMethodCall() throws Throwable {
        System.out.println("进入后置增强了！");
    }
}

获取切入点方法的参数

@Configuration
@Aspect
public class UserInfoAspect {
    @Pointcut("execution(* com.*.test(*))")
    public void test() {}
    
    //使用JoinPoint 对象可以接收到切入点方法的参数
    @AfterReturning(value = "test()")
    public void logMethodCall(JoinPoint jp) throws Throwable {
        System.out.println("进入后置增强了！");
        String name = jp.getSignature().getName();
        System.out.println(name);
        Object[] args = jp.getArgs();
        for (Object arg : args) {
            System.out.println("参数：" + arg);
        }
    }
 }

获取切点方法返回值

@Configuration
@Aspect
public class UserInfoAspect {
    @Pointcut("execution(* com.*.test(*))")
    public void test() {}
    
    //在事件通知类型中申明returning即可获取返回值
    @AfterReturning(value = "test()", returning="returnValue")
    public void logMethodCall(JoinPoint jp, Object returnValue) throws Throwable {
        System.out.println("进入后置增强了！");
        String name = jp.getSignature().getName();
        System.out.println(name);
        Object[] args = jp.getArgs();
        for (Object arg : args) {
            System.out.println("参数：" + arg);
        }
        System.out.println("方法返回值为：" + returnValue);
    }
}

如果你想同时拥有多个切入点的话，可以使用逻辑操作符 “&&”，“||”等

@Pointcut("execution(* com.*.(*))")
public void addUser() {}
   
@Pointcut("execution(* com.*.(*))")
public void updateUser() {}
@After(value = "addUser() || updateUser()", returning="returnValue")
public void pushAccountInfo(JoinPoint jp, Object returnValue){
    //这里写切面逻辑：
}

多数据源

Mybatisplus dynamic-datasource-spring-boot-starter 遇到的问题

报错

Failed to configure a DataSource: ‘url’ attribute is not specified and no embedded datasource could be configured.

SpringBoot 默认是单一数据源自动配置加载，所以禁止 SpringBoot 自动注入数据源配置即可解决

解决

@SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class)

MyBatisPlus-数据源

日夜颠倒头发少，单纯好骗恋爱脑，会背九九乘法表，下雨只会往家跑，搭讪只会说你好 ---- 2050781802@qq.com