Mit welcher Methode transformiert ssm das Spring-Boot-Projekt?

Abhängigkeiten hinzufügen

Wenn es sich um ein normales Maven-Projekt handelt, müssen Sie es manuell hinzufügen.

<!-- 打包方式 jar 包 -->
<packaging>jar</packaging>

<!-- 指定父工程 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
</parent>

<dependencies>
    <!-- spring boot Web 包 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- spring boot Test 包 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>

Startup-Klasse hinzufügen

Wenn es sich um ein normales Maven-Projekt handelt, muss es manuell hinzugefügt werden.

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

Kopieren Sie den Projektcode

• Kopieren Sie den gesamten Java-Code in srcmainjava nach srcmainjava im neuen Projekt.

• Kopieren Sie das Verzeichnis, in dem mapper.xml in srcmainresources gespeichert ist, nach srcmainresources im neuen Projekt.

Was in den folgenden Schritten kopiert werden soll

Konfigurieren Sie den Datenbankverbindungspool

Hinzufügen von Abhängigkeiten

<!-- MySQL 驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

Sie benötigen außerdem JDBC-Abhängigkeiten (Transaktionen)

Automatische Konfigurationsmethode des Verbindungspools

application.properties

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql:///数据库库名?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=admin

Führen Sie zu diesem Zeitpunkt den Test aus. Das erhaltene Datenbankverbindungspoolobjekt kann erfolgreich ausgeführt werden. Wir sehen, dass der verwendete Verbindungspool Hikari ist, dessen vollständiger Name Hikaricp ist.

Tatsächlich wird nach Spring Boot 2.0 der standardmäßig verwendete Verbindungspool Hikari verwendet, der als „schnellster Verbindungspool in der Geschichte“ bekannt ist, sodass wir ihn direkt verwenden können, ohne Abhängigkeiten hinzuzufügen. Die automatische Konfiguration von Spring Boot enthält die Konfigurationsklasse DataSourceAutoConfiguration Es wird zunächst geprüft, ob sich im Container ein Verbindungspoolobjekt befindet. Wenn nicht, wird der Standardverbindungspool verwendet und das Verbindungspoolobjekt wird automatisch entsprechend den spezifischen Eigenschaften konfiguriert DataSourceProperties-Objekt.

Konfigurieren des Druid-Verbindungspools

Wenn wir Druid weiterhin als Verbindungspool im Projekt verwenden möchten, ist dies natürlich auch möglich. Sie müssen nur Abhängigkeiten hinzufügen. Zu diesem Zeitpunkt wird das automatische Konfigurationspaket druid-spring-boot-starter von Druid hinzugefügt, das die automatische Konfigurationsklasse DruidDataSourceAutoConfigure enthält, die automatisch das Druid-Verbindungspoolobjekt erstellt, also Spring Boot stellt fest, dass es bereits vorhanden ist. Wenn das Verbindungspoolobjekt entfernt wird, wird Hikari nicht mehr verwendet.

<!-- druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>

Hinweis: Wenn es sich bei der hinzugefügten Abhängigkeit um das vorherige normale Paket handelt, das nur von Druid selbst abhängt und kein automatisches Konfigurationspaket ist, müssen Sie Folgendes konfigurieren:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.19</version>
</dependency>

Parameter in der Konfigurationsdatei hinzufügen

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

Wenn also im Allgemeinen das Spring Boot-bezogene automatische Konfigurationspaket bereitgestellt wurde, ist es bequemer, die automatische Konfiguration direkt zu verwenden.

Für Hikari und Druid handelt es sich bei Alibabas Druid um eine chinesische Open-Source-Community, die nach Experimenten mit mehreren Alibaba-Systemen auch sehr stabil ist, und Hikari ist Spring Der Standard-Verbindungspool 2.0 ist in den meisten Unternehmen nahezu identisch. Schließlich liegt der Leistungsengpass nicht im Verbindungspool.

Integrieren Sie MyBatis.

Abhängigkeit hinzufügen.

<!-- Mybatis 集成到 SpringBoot 中的依赖 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.1</version>
</dependency>

.Mapper-Objekt konfigurieren.

@SpringBootApplication
@MapperScan("cn.xxx.mapper")
public class SsmApplication {
    public static void main(String[] args) {
        SpringApplication.run(SsmApplication.class, args);
    }
}

MyBatis-Konfigurationseigenschaften

Konfigurieren Sie die zuvor in XML konfigurierten MyBatis-Eigenschaften in application.properties mit dem Eigenschaftspräfix mybatis.

# 配置别名
mybatis.type-aliases-package=cn.xxx.domain

# 打印 SQL 日志
logging.level.cn.xxx.mapper=trace

Transaktionsverwaltung@MapperScan 并指定扫描的包路径即可。

<!-- Spring JDBC 和 TX -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

MyBatis配置属性

在 application.properties 配置以前在 XML 配置了的那些 MyBatis 的属性，属性前缀 mybatis。

spring.aop.proxy-target-class=false

事务管理

添加依赖

@Test
public void testSave() {
    System.out.println(departmentService.getClass());
}

注解方式

直接在业务层实现类上或者其方法上直接贴 @Transactional 注解即可。

Spring Boot 自动配置中提供了 TransactionAutoConfiguration 事务注解自动配置类，引入了事务的依赖后，可直接使用 @TransactionalAbhängigkeiten hinzufügen

<!-- spring boot web 启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Annotationsmethode

Fügen Sie die Annotation @Transactional direkt in die

Business-Layer-Implementierungsklasse oder deren Methode ein

.

Die automatische Konfiguration von Spring Boot stellt die automatische Konfigurationsklasse „TransactionAutoConfiguration“ für Transaktionsanmerkungen bereit. Nach der Einführung von Transaktionsabhängigkeiten kann die Annotation @Transactional direkt verwendet werden.

Switching-Agent konfigurieren

Spring Boot gibt dem CGLIB-Agenten standardmäßig Priorität. Wenn Sie zuerst auf die Verwendung des JDK-Agenten umsteigen müssen, müssen Sie die folgende Konfiguration vornehmen:

server.port=80

Testüberprüfung

Fügen Sie eine Methode hinzu Testen Sie die Klasse und drucken Sie das Geschäftsobjekt aus, um seinen Realitätstyp anzuzeigen.

# 告诉 Spring Boot 必须要以怎样的路径开头才能访问到静态资源,这样做是为了后期如果需要拦截,拦截器可以统一排除掉这些以这个开头的访问
spring.mvc.static-path-pattern=/static/**

Web integrieren

Abhängigkeiten hinzufügen

# 在匹配模式时是否使用后缀模式匹配(严格匹配后缀)一般前后端分离做严格区分时配置
spring.mvc.pathmatch.use-suffix-pattern=true

Port ändern

Konfigurieren Sie in application.properties wie folgt:

<!-- 引入 Thymeleaf 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Verzeichnisstruktur

• Statische Ressourcen und Vorlagendateien kopieren

• Einige Verarbeitung von statischen Ressourcen

• Standardmäßig lädt Spring Boot statische Ressourcen aus /static, /public, /resources, /META-INF/resources unter dem Klassenpfad.

Sie können die Eigenschaft spring.resources.staticLocations in application.properties konfigurieren, um die Standardladeadresse statischer Ressourcen zu ändern.

🎜Da die Anwendung in ein JAR-Paket gepackt ist, ist die vorherige Datei src/main/webapp ungültig. Wenn Dateien hochgeladen werden müssen, müssen Sie den Pfad zum Speichern des Bildes konfigurieren, da das Bild nicht im gespeichert werden kann jar-Paket. Der vorherige Krieg Es kann nur die Paketmethode verwendet werden. 🎜🎜🎜

# Thymelea 模板配置
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html 
spring.thymeleaf.mode=HTML
spring.thymeleaf.encoding=UTF-8
# 上面几个配置都是默认值不需要配置

# 热部署文件，页面不产生缓存，及时更新(开发时禁用缓存)
spring.thymeleaf.cache=false

🎜Konfiguration des Front-End-Controller-Zuordnungspfads🎜🎜In der automatischen Konfiguration von Spring Boot importiert die automatische Konfigurationsklasse WebMvcAutoConfiguration das Konfigurationsobjekt DispatcherServletAutoConfiguration, das automatisch den DispatcherServlet-Front-End-Controller erstellt Wird hauptsächlich von Spring Boot verwendet. Für die Front-End- und Back-End-Trennung sowie die Microservice-Entwicklung wird der RESTFul-Stil standardmäßig unterstützt, sodass Sie im Allgemeinen den Standard verwenden können, ohne Änderungen vorzunehmen. 🎜

# 在匹配模式时是否使用后缀模式匹配(严格匹配后缀)一般前后端分离做严格区分时配置
spring.mvc.pathmatch.use-suffix-pattern=true

集成 Thymeleaf

添加依赖

<!-- 引入 Thymeleaf 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

相关配置

# Thymelea 模板配置
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html 
spring.thymeleaf.mode=HTML
spring.thymeleaf.encoding=UTF-8
# 上面几个配置都是默认值不需要配置

# 热部署文件，页面不产生缓存，及时更新(开发时禁用缓存)
spring.thymeleaf.cache=false

修改模板文件

使用 Thymeleaf 的语法替换之前 JSP 中的 EL 表达式和 JSTL。

统一异常处理

框架自带方式

Spring Boot 默认情况下，会把所有错误都交给 BasicErrorController 类完成处理，错误的视图我们放到 classpath:/static/error/ 和 classpath:/templates/error/ 路径上，HTTP 错误状态码就是默认视图的名称。如：

• 出现 404 错误 -> classpath:/static/error/404.html

• 出现 5xx 错误 -> classpath:/static/error/5xx.html (因为 5xx 错误是后台错误, 原因很多种, 有时有需求需要根据原因不一样响应不同的内容, 甚至响应数据格式都不一样,所以我们一般都用统一异常处理,然后再根据错误原因把对应内容放到页面上)

控制器增强器方式

自己定义一个控制器增强器，专门用于统一异常处理，该方式一般用于处理 5xx 类错误。

@ControllerAdvice 
// 控制器消息,这个注解为了spring帮我们创建对象
public class ExceptionControllerAdvice {
    @ExceptionHandler(RuntimeException.class) // 处理什么类型的异常
    //返回值形式也可以自定义,可以返回modelAndView,
    public String handlException(RuntimeException e, Model model,HandlerMethod m) {
    	//HandlerMethod这个对象存放了spring对控制器的方法和控制器对象
    	//将错误信息存入到model中
        e.printStackTrace(); // 记得这行代码保留，不然项目后台出异常，开发工具控制台看不到错误信息
        return "errorView"; // 指定错误页面视图名称,然后在页面从model对象中拿到错误信息
    }
}

添加注册多个拦截器

定义一个配置类，实现 WebMvcConfigurer 接口，在 addInterceptors 方法注册拦截器。

@Configuration
public class MvcJavaConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;
    //拦截器类实现HandlerInterceptor

    @Autowired
    private PermissionInterceptor permissionInterceptor;
    //拦截器类实现HandlerInterceptor

    public void addInterceptors(InterceptorRegistry registry) {
        // 注册登录拦截器
        registry.addInterceptor(loginInterceptor)
            // 对哪些资源起过滤作用
            .addPathPatterns("/**")
            // 对哪些资源起排除作用
            .excludePathPatterns("/login", "/static/**");//多个路径
            
		//多个拦截器
        // 注册权限拦截器
        registry.addInterceptor(permissionInterceptor)
            // 对哪些资源起过滤作用
            .addPathPatterns("/**")
            // 对哪些资源起排除作用
            .excludePathPatterns("/login", "/static/**");
    }
}

系统日志

为什么要用日志

• 比起 System.out.println，日志框架更为灵活，可以把日志的输出和代码分离。

• 日志框架可以方便的定义日志的输出环境，控制台，文件，数据库。

• 日志框架可以方便的定义日志的输出格式和输出级别。

Spring Boot 中的日志介绍

• Spring Boot 默认已经开启日志，其默认的日志格式为：时间 日志级别 线程ID 线程名称 日志类 日志说明。

• Spring Boot 的日志分为：系统日志和应用日志。

• 日志级别，级别越高，输出的内容越少，如果设置的级别为 info，则 debug 以及 trace 级别的都无法显示，日志级别由低到高 trace < debug < info < warn < error。

• Spring Boot 默认选择 Logback 作为日志框架，也能选择其他日志框架，但是没有必要。

由于slf4j是后来出现的日志标准,目的是统一之前很多日志框架的使用方式,对主流的日志框架主动的实现了这个标准,实际就是调用各日志框架的api

输出日志

在我们自定义的类中可以使用日志框架来输出。

方式一

在类中注入一个静态 Logger 对象，传入当前类的作用是方便输出日志时可以清晰地看到该日志信息是属于哪个类的。

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

方式二

使用 Lombok 提供的 @Slf4j 注解来简化代码，其实和方式一的作用是一样的。

@Slf4j
@Service
public class PermissionServiceImpl implements IPermissionService {}

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

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

日志级别

日志级别由低到高 trace < debug < info < warn < error。

log.debug("权限插入成功：{}"，expression);
log.info("权限插入成功：{}"，expression);
log.warn("权限插入成功：{}"，expression);

执行权限加载功能后，发现控制台出现 info 与 warn 的信息，debug 的没有显示，原因是因为 Spring Boot 默认的日志级别是 info，所以 debug 低于 info 级别，就不会显示出来了。

若要修改日志显示级别，最快速的方式是在 application.properties 配置，配置如下

# 把日志级别修改为 debug，不过我们一般不会更改，除非要调试找 bug，不然控制台显示的内容太多也容易乱,下面为全局配置,单路径配置如打印 SQL 日志 logging.level.cn.xxx.mapper=trace
logging.level.root=debug

Logback 配置文件,日志存入文件中

Logback 框架默认会自动加载 classpath:logback.xml，作为框架的配置文件，在 Spring Boot项目中使用时，还会额外的支持自动加载classpath:logback-spring.xml，在 Spring Boot 项目中推荐使用 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：按照级别输出日志，日志级别，级别越高，输出的内容越少
    -->
　　 <root level="info">
        <appender-ref ref="STDOUT" /> <!-- 日志输出到控制台还是存入文件中 -->
    </root>
    
    <!-- 自定义的 logger，用于专门输出特定包中打印的日志
    <logger name="cn.xxx.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：所在线程名称

一般开发过程,日志记录到控制台

实际上线了, 日志一般记录到文件中

其他功能

修改spring boot启动打印画面

Spring Boot 提供了一些扩展点，比如修改 banner：在 resources 根目录中放入 banner.txt 文件，替换默认的启动spring打印的字样。

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

热部署插件

除了使用 JRebel 插件(收费)来实现热部署，还可以使用 Spring Boot 提供的 spring-boot-devtools 包来完成 Springboot 应用热部署,从而实现更改方法内代码和模板文件不需要重启,只需要点击编译即可。

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

Spring Boot 重启是 reload 重启，通过监控 classpath 的变化，如果 classpath 中的文件发生变化，即触发重启。Spring Boot 通过两个 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

切换运行环境

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

# application-dev.properties
server.port=8081

# application-test.properties
server.port=8082

最后我们在 application.properties 中指定需要使用的环境即可

# 在 application.properties 中指定需要使用的环境即可
spring.profiles.active=dev

在命令行模式下启动也可以激活: java -jar xxx --spring.profiles.active=dev

Das obige ist der detaillierte Inhalt vonMit welcher Methode transformiert ssm das Spring-Boot-Projekt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!