S'il s'agit d'un projet Maven normal, vous devez l'ajouter manuellement.
<!-- 打包方式 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>S'il s'agit d'un projet Maven normal, il doit être ajouté manuellement.
@SpringBootApplication
public class xxxApplication {
public static void main(String[] args) {
SpringApplication.run(xxxApplication.class, args);
}
}Copiez tout le code Java de srcmainjava vers srcmainjava dans le nouveau projet.
Copiez le répertoire où mapper.xml est stocké dans srcmainresources vers srcmainresources dans le nouveau projet.
Que copier dans les étapes suivantes
<!-- MySQL 驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>Vous avez également besoin de dépendances jdbc (transactions)
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
Exécutez le test à ce moment-là. L'objet pool de connexions à la base de données obtenu peut être exécuté avec succès, et nous voyons que le pool de connexions utilisé est Hikari, dont le nom complet est Hikaricp.
En fait, après Spring Boot 2.0, le pool de connexions par défaut utilisé est Hikari, connu comme "le pool de connexions le plus rapide de l'histoire", nous pouvons donc l'utiliser directement sans ajouter de dépendances. La configuration automatique de Spring Boot contient la classe de configuration DataSourceAutoConfiguration. , il vérifiera d'abord s'il y a un objet pool de connexions dans le conteneur. Sinon, le pool de connexions par défaut sera utilisé et l'objet pool de connexions sera automatiquement configuré en fonction de propriétés spécifiques. Objet DataSourceProperties.
Bien sûr, si nous souhaitons toujours utiliser Druid comme pool de connexions dans le projet, c'est également possible. Il vous suffit d'ajouter des dépendances. Ce qui est ajouté à ce moment est le package de configuration automatique druid-spring-boot-starter de Druid, qui contient la classe de configuration automatique DruidDataSourceAutoConfigure, qui créera automatiquement l'objet pool de connexion Druid, donc Spring. Le démarrage constate qu'il existe déjà. Si l'objet pool de connexions est supprimé, Hikari ne sera plus utilisé.
<!-- druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.21</version>
</dependency>Remarque : Si la dépendance ajoutée est le package ordinaire précédent, qui ne dépend que de Druid lui-même et n'est pas un package de configuration automatique, vous devez configurer les éléments suivants :
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.19</version>
</dependency>Ajouter des paramètres dans le fichier de configuration
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
Donc, généralement, si le package de configuration automatique lié à Spring Boot a été fourni, il sera plus pratique d'utiliser directement la configuration automatique.
Pour Hikari et Druid, les deux sont des produits open source. Druid d'Alibaba dispose d'une communauté open source chinoise, ce qui est plus pratique pour la communication. Après des expériences avec plusieurs systèmes Alibaba, elle est également très stable, et Hikari est Spring. Boot. Le pool de connexions par défaut 2.0 est largement utilisé dans le monde entier. Pour la plupart des entreprises, il est presque le même, quelle que soit celle utilisée. Après tout, le goulot d'étranglement des performances ne réside généralement pas dans le pool de connexions.
<!-- Mybatis 集成到 SpringBoot 中的依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.1</version>
</dependency>Interface Scan MapperPubliez simplement une annotation @MapperScan sur n'importe quelle classe de configuration et spécifiez le chemin du package à analyser. @MapperScan 并指定扫描的包路径即可。
@SpringBootApplication
@MapperScan("cn.xxx.mapper")
public class SsmApplication {
public static void main(String[] args) {
SpringApplication.run(SsmApplication.class, args);
}
}在 application.properties 配置以前在 XML 配置了的那些 MyBatis 的属性，属性前缀 mybatis。
# 配置别名 mybatis.type-aliases-package=cn.xxx.domain # 打印 SQL 日志 logging.level.cn.xxx.mapper=trace
<!-- Spring JDBC 和 TX -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>直接在业务层实现类上或者其方法上直接贴 @Transactional 注解即可。
Spring Boot 自动配置中提供了 TransactionAutoConfiguration 事务注解自动配置类，引入了事务的依赖后，可直接使用 @Transactional
spring.aop.proxy-target-class=false
@Test
public void testSave() {
System.out.println(departmentService.getClass());
}<!-- spring boot web 启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>@Transactional directement sur la @Transactional peut être utilisée directement. Configurer l'agent de commutationSpring Boot donne la priorité à l'agent CGLIB par défaut Si vous devez d'abord modifier pour utiliser l'agent JDK, vous devez d'abord effectuer la configuration suivante : server.port=80
Ajouter une méthode au. testez la classe et imprimez l’objet métier pour voir son type de réalité.
# 告诉 Spring Boot 必须要以怎样的路径开头才能访问到静态资源,这样做是为了后期如果需要拦截,拦截器可以统一排除掉这些以这个开头的访问 spring.mvc.static-path-pattern=/static/**
# 在匹配模式时是否使用后缀模式匹配(严格匹配后缀)一般前后端分离做严格区分时配置 spring.mvc.pathmatch.use-suffix-pattern=true
Modifier le port
<!-- 引入 Thymeleaf 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>Structure des répertoires
Par défaut, Spring Boot chargera les ressources statiques de /static, /public, /resources, /META-INF/resources sous le chemin de classe. 🎜🎜🎜🎜Vous pouvez configurer la propriété spring.resources.staticLocations dans application.properties pour modifier l'adresse de chargement par défaut des ressources statiques. 🎜🎜🎜🎜Étant donné que l'application est emballée dans un package jar, le src/main/webapp précédent n'est pas valide. S'il y a des fichiers à télécharger, vous devez configurer le chemin pour enregistrer l'image, car l'image ne peut pas être stockée dans le fichier. jar Package.La guerre précédente Seule la méthode package peut être utilisée. 🎜🎜🎜
# Thymelea 模板配置 spring.thymeleaf.prefix=classpath:/templates/ spring.thymeleaf.suffix=.html spring.thymeleaf.mode=HTML spring.thymeleaf.encoding=UTF-8 # 上面几个配置都是默认值不需要配置 # 热部署文件，页面不产生缓存，及时更新(开发时禁用缓存) spring.thymeleaf.cache=false
# 在匹配模式时是否使用后缀模式匹配(严格匹配后缀)一般前后端分离做严格区分时配置 spring.mvc.pathmatch.use-suffix-pattern=true
<!-- 引入 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 默认已经开启日志，其默认的日志格式为：时间 日志级别 线程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 框架默认会自动加载 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 提供了一些扩展点，比如修改 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
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Étapes de création du projet SpringBoot
Quelle est la différence entre j2ee et springboot
Le rôle de Vulkan
Comment convertir un pdf au format XML
securefx ne peut pas se connecter
Quelles sont les principales fonctions de Redis ?
Quelle est la différence entre 5g et 4g
La différence entre scratch et python
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
