Spring-Boot on Dapeng Zhang

vscode run spring boot - The newly created daemon process has a different context than expected

Wed, 30 Jul 2025 11:43:40 +0800

针对问题

先说下本机器默认java版本


$ java -version
java version "1.8.0_121"
Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

在使用vscode创建spring boot项目的时候，遇到一个问题，就是vscode会提示你

“Java 11 or more recent is required to run. Please download and install a recent JDK”

我以为应该要用java 11

于是我就用brew 安装了java 11，安装后的信息如下


$ brew info openjdk@11
openjdk@11: stable 11.0.8 (bottled) [keg-only]
Development kit for the Java programming language
https://openjdk.java.net/
/usr/local/Cellar/openjdk@11/11.0.8 (650 files, 295.3MB)
 Poured from bottle on 2020-10-19 at 12:19:32
From: https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/[email protected]
License: GPL-2.0
==> Dependencies
Build: autoconf ✔
==> Caveats
For the system Java wrappers to find this JDK, symlink it with
 sudo ln -sfn /usr/local/opt/openjdk@11/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk-11.jdk

openjdk@11 is keg-only, which means it was not symlinked into /usr/local,
because this is an alternate version of another formula.

If you need to have openjdk@11 first in your PATH run:
 echo 'export PATH="/usr/local/opt/openjdk@11/bin:$PATH"' >> ~/.zshrc

For compilers to find openjdk@11 you may need to set:
 export CPPFLAGS="-I/usr/local/opt/openjdk@11/include"

==> Analytics
install: 29,975 (30 days), 70,671 (90 days), 111,102 (365 days)
install-on-request: 18,766 (30 days), 30,811 (90 days), 53,043 (365 days)
build-error: 0 (30 days)

然后我需要用到java 11在vscode中，在setting加入如下参数配置


"java.home": "/usr/local/Cellar/openjdk@11/11.0.8/"

然后运行sping boot项目，遇到了类似如下的问题

The newly created daemon process has a different context than expected.
It won’t be possible to reconnect to this daemon. Context mismatch:
Java home is different.
Wanted: DefaultDaemonContext[…]
Actual: DefaultDaemonContext[…]

经过google搜索一大堆的那个什么ide的问题

主要原因在这里

https://github.com/redhat-developer/vscode-java/wiki/JDK-Requirements#java.configuration.runtimes

只需要将


"java.home": "/usr/local/Cellar/openjdk@11/11.0.8/",

替换并修改为如下


"java.home": "/usr/local/Cellar/openjdk@11/11.0.8/libexec/openjdk.jdk/Contents/Home/",
"java.configuration.runtimes": [
 {
 "name": "JavaSE-11",
 "path": "/usr/local/Cellar/openjdk@11/11.0.8/libexec/openjdk.jdk/Contents/Home/"
 },
]

再次运行，问题解决，其实github上的一篇文章写的比较详细

Spring - Spring Boot 2.4.0.M3发布

Wed, 30 Jul 2025 11:03:55 +0800

Spring Boot 2.4.0发布

亮点如下

Java 15 support
A new Startup actuator endpoint
Docker authentication support
Config data import improvements
Numerous dependency upgrades

具体的改变列表和升级说明，请点击这里 Spring Boot 2.4 Release Notes 和 updated reference documentation.

如果你想要体验2.4的新特性，你可以到 https://start.spring.io 新建一个项目

原文发布时间：SEPTEMBER 17, 2020

原文地址：https://spring.io/blog/2020/09/17/spring-boot-2-4-0-m3-available-now

Spring boot基础学习记录之与Redis消息传递

Tue, 29 Jul 2025 10:09:03 +0800

与Redis消息传递(Messaging with Redis)

本篇文章学习下如何使用Spring Data Redis发布和订阅通过Redis发送的消息的过程。

一改之前的风格，之前的依赖库都使用的是Maven，本次换个风格，来尝试下Gradle，啊！敲个字都比Maven多一个字母，累呀，希望能体验到Gradle的优点，带给我一些开发效率的提升

1、Build With Gradle

Gradle原来的库如下，修改了很多，开始的时候，手动创建，然后参考官网，将依赖一个一个的加进来了，最后发现少了一个gradlew，当时奇怪为什么没有，查了资料原来可以使用
gradle init创建，不过build.gradle需要重新生成，我就备份了一下，然后又重新的copy进来的，最后就有了下面的结果，开始的时候使用VScode，哎废了半天时间，也没有找到具体如何自动进行更新依赖的。
最后换了IntelliJ IDEA，果然强大，也说明了，要做Java开发，还是要有个这么强大的工具才行，果然体量重。


buildscript {
 repositories {
 mavenCentral()
 }
 dependencies {
 classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE")
 }
}

apply plugin: 'java'
apply plugin: 'maven'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

group = 'com.gowhich'
version = '0.0.1-SNAPSHOT'

description = """Demo project for Spring Boot"""

bootJar {
 baseName = 'spring-demo'
 version = '1.0'
}

sourceCompatibility = 1.8
targetCompatibility = 1.8
tasks.withType(JavaCompile) {
	options.encoding = 'UTF-8'
}

repositories {
 mavenCentral()
}
dependencies {
 compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version:'2.0.2.RELEASE'
 compile group: 'org.springframework.boot', name: 'spring-boot-starter-jdbc', version:'2.0.2.RELEASE'
 compile group: 'com.h2database', name: 'h2', version:'1.4.197'
 compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf', version:'2.0.2.RELEASE'
 compile group: 'org.springframework.boot', name: 'spring-boot-starter-security', version:'2.0.2.RELEASE'
 compile group: 'org.springframework.ldap', name: 'spring-ldap-core', version:'2.3.2.RELEASE'
 compile group: 'org.springframework.security', name: 'spring-security-ldap', version:'5.0.5.RELEASE'
 compile group: 'com.unboundid', name: 'unboundid-ldapsdk', version:'4.0.5'
 compile group: 'org.springframework.social', name: 'spring-social-facebook', version:'2.0.3.RELEASE'
 compile group: 'com.fasterxml.jackson.core', name: 'jackson-core', version:'2.9.5'
 compile group: 'org.springframework.security', name: 'spring-security-crypto', version:'5.0.5.RELEASE'
 compile group: 'org.springframework.social', name: 'spring-social-core', version:'1.1.6.RELEASE'
 compile group: 'org.springframework.social', name: 'spring-social-security', version:'1.1.6.RELEASE'
 compile group: 'org.springframework.security', name: 'spring-security-core', version:'5.0.6.RELEASE'
 compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-redis', version: '2.0.4.RELEASE'
 testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version:'2.0.2.RELEASE'
 testCompile group: 'org.springframework.security', name: 'spring-security-test', version:'5.0.5.RELEASE'
}

贴出来这么多，其实只有下面两行跟本次内容有关


compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-redis', version: '2.0.4.RELEASE'

主要是这个。

2、启动Redis服务器

在构建消息传递应用程序之前，需要设置将处理接收和发送消息的服务器。
Redis是一个开源的，BSD许可的键值数据存储，它还附带了一个消息传递系统。
该服务器可在http://redis.io/download免费获得。
您可以手动下载，或者如果您使用带自制程序的Mac：


brew install redis

解压缩Redis后，可以使用默认设置启动它。


redis-server

你应该看到这样的消息：


69673:C 21 Sep 15:38:57.755 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
69673:C 21 Sep 15:38:57.756 # Redis version=4.0.9, bits=64, commit=00000000, modified=0, pid=69673, just started
69673:C 21 Sep 15:38:57.756 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
69673:M 21 Sep 15:38:57.758 * Increased maximum number of open files to 10032 (it was originally set to 7168).
 _._
 _.-``__ ''-._
 _.-`` `. `_. ''-._ Redis 4.0.9 (00000000/0) 64 bit
 .-`` .-```. ```\/ _.,_ ''-._
 ( ' , .-` | `, ) Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'| Port: 6379
 | `-._ `._ / _.-' | PID: 69673
 `-._ `-._ `-./ _.-' _.-'
 |`-._`-._ `-.__.-' _.-'_.-'|
 | `-._`-._ _.-'_.-' | http://redis.io
 `-._ `-._`-.__.-'_.-' _.-'
 |`-._`-._ `-.__.-' _.-'_.-'|
 | `-._`-._ _.-'_.-' |
 `-._ `-._`-.__.-'_.-' _.-'
 `-._ `-.__.-' _.-'
 `-._ _.-'
 `-.__.-'

69673:M 21 Sep 15:38:57.759 # Server initialized
69673:M 21 Sep 15:38:57.759 * DB loaded from disk: 0.000 seconds
69673:M 21 Sep 15:38:57.759 * Ready to accept connections

3、创建Redis消息接收器

在任何基于消息传递的应用程序中，都有消息发布者和消息接收者。
要创建消息接收器，需要实现具有响应消息的方法的接收器：
src/main/java/com/gowhich/springdemo/Receiver.java


package com.gowhich.springdemo;

import java.util.concurrent.CountDownLatch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

public class Receiver {

 private static final Logger LOGGER = LoggerFactory.getLogger(Receiver.class);

 private CountDownLatch latch;

 @Autowired
 public Receiver(CountDownLatch latch) {
 this.latch = latch;
 }

 public void receiveMessage(String message) {
 LOGGER.info("Received <" + message + ">");
 latch.countDown();
 }
}

Receiver是一个简单的POJO，它定义了一种接收消息的方法。
正如您在将Receiver注册为消息侦听器时所看到的那样，您可以根据需要为消息处理方法命名。

出于演示目的，它由构造函数自动装配，具有倒计时锁存器。这样，它可以在收到消息时发出信号。

4、注册监听器并发送消息

Spring Data Redis提供了使用Redis发送和接收消息所需的所有组件。具体来说，您需要配置：

连接工厂
消息侦听器容器
Redis模板

您将使用Redis模板发送消息，并且您将使用消息侦听器容器注册Receiver，以便它将接收消息。
连接工厂驱动模板和消息侦听器容器，使它们能够连接到Redis服务器。

此示例使用Spring Boot的默认RedisConnectionFactory，这是一个基于Jedis Redis库的JedisConnectionFactory实例。
连接工厂将注入消息侦听器容器和Redis模板。启动文件src/main/java/com/gowhich/springdemo/SpringDemoApplication.java中加入如下代码


private static final Logger LOGGER = LoggerFactory.getLogger(SpringDemoApplication.class);

@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {
 RedisMessageListenerContainer container = new RedisMessageListenerContainer();
 container.setConnectionFactory(connectionFactory);
 container.addMessageListener(listenerAdapter, new PatternTopic("chat"));
 return container;
}

@Bean
MessageListenerAdapter listenerAdapter(Receiver receiver) {
 return new MessageListenerAdapter(receiver, "receiveMessage");
}

@Bean
Receiver receiver(CountDownLatch latch) {
 return new Receiver(latch);
}

@Bean
CountDownLatch latch() {
 return new CountDownLatch(1);
}

@Bean
StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
 return new StringRedisTemplate(connectionFactory);
}

public static void main(String[] args) throws InterruptedException {
 ApplicationContext ctx = SpringApplication.run(SpringDemoApplication.class, args);

 StringRedisTemplate template = ctx.getBean(StringRedisTemplate.class);
 CountDownLatch latch = ctx.getBean(CountDownLatch.class);

 LOGGER.info("Sending message ...");

 template.convertAndSend("chat", "Hello from walkerfree!");

 latch.await();

 System.exit(0);
}

listenerAdapter方法中定义的bean在容器中定义的消息侦听器容器中注册为消息侦听器，并将侦听"chat"主题上的消息。
由于Receiver类是POJO，因此需要将其包装在消息侦听器适配器中，该适配器实现addMessageListener()所需的MessageListener接口。
消息侦听器适配器还配置为在消息到达时调用Receiver上的receiveMessage()方法。
连接工厂和消息监听器容器bean是监听消息所需的全部内容。
要发送消息，您还需要Redis模板。
这里，它是一个配置为StringRedisTemplate的bean，它是RedisTemplate的一个实现，专注于Redis的常用用法，其中键和值都是Strings。
main()方法通过创建Spring应用程序上下文来解决所有问题。
然后，应用程序上下文启动消息侦听器容器，并且消息侦听器容器bean开始侦听消息。
然后main()方法从应用程序上下文中检索StringRedisTemplate bean，并使用它发送"Hello from walkerfree!"
关于"chat"主题的消息。
最后，它关闭Spring应用程序上下文，应用程序结束。

5、构建可执行的JAR

您可以使用Gradle或Maven从命令行运行该应用程序。
或者，您可以构建一个包含所有必需依赖项，类和资源的可执行JAR文件，并运行该文件。
这使得在整个开发生命周期中，跨不同环境等将服务作为应用程序发布，版本和部署变得容易。

使用./gradlew bootRun运行该应用程序。
或者可以使用./gradlew build构建JAR文件。
然后你可以运行JAR文件：


java -jar build/libs/spring-demo-1.0.jar

您应该看到以下输出：


2018-09-21 15:25:48.158 INFO 69170 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2018-09-21 15:25:48.179 INFO 69170 --- [ main] o.s.c.support.DefaultLifecycleProcessor : Starting beans in phase 2147483647
2018-09-21 15:25:48.359 INFO 69170 --- [ container-1] io.lettuce.core.EpollProvider : Starting without optional epoll library
2018-09-21 15:25:48.364 INFO 69170 --- [ container-1] io.lettuce.core.KqueueProvider : Starting without optional kqueue library
2018-09-21 15:25:48.755 INFO 69170 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2018-09-21 15:25:48.764 INFO 69170 --- [ main] c.g.springdemo.SpringDemoApplication : Started SpringDemoApplication in 9.342 seconds (JVM running for 9.993)
2018-09-21 15:25:48.783 INFO 69170 --- [ main] c.g.springdemo.SpringDemoApplication : Sending message ...
2018-09-21 15:25:48.806 INFO 69170 --- [ container-2] com.gowhich.springdemo.Receiver : Received <Hello from walkerfree!>

Spring boot基础学习记录之完善通过Facebook注册一个应用

Tue, 29 Jul 2025 10:08:56 +0800

继续上篇文章，来完善下如果使用Facebook注册一个应用
今天通过官网有查到了许多关于spring boot social相关的文章，但是进去之后都只能看到"deprecated"
今天我就来完善下这块知识的短缺

首先在社交平台注册一个应用 (Register your application)

比如注册Facebook Twitter等应用，可以去官网看看教程，这个跟国内的微博之类的是类似的，这里不做简单介绍了。而且每个不同平台的版本升级，界面变化也是蛮快的，建议多去官网看看。

编辑应用的配置添加配置属性 (Edit application.properties)

我这里修改了application.properties添加了下面的配置，其他平台的类似


facebook.appKey=xxx
facebook.appSecret=xxx

依据上篇文章已经添加的，这里的话，还需要在添加几个如下


<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-core</artifactId>
 <version>1.1.6.RELEASE</version>
</dependency>
<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-security</artifactId>
 <version>1.1.6.RELEASE</version>
</dependency>
<dependency>
 <groupId>org.springframework.security</groupId>
 <artifactId>spring-security-core</artifactId>
 <version>5.0.6.RELEASE</version>
</dependency>

最终总共需要添加的依赖如下


<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-facebook</artifactId>
 <version>2.0.3.RELEASE</version>
</dependency>
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-core</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.security</groupId>
 <artifactId>spring-security-crypto</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-core</artifactId>
 <version>1.1.6.RELEASE</version>
</dependency>
<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-security</artifactId>
 <version>1.1.6.RELEASE</version>
</dependency>
<dependency>
 <groupId>org.springframework.security</groupId>
 <artifactId>spring-security-core</artifactId>
 <version>5.0.6.RELEASE</version>
</dependency>

飙写代码开始

1、创建一个@Configuration类：


@Configuration
@EnableSocial
public class SocialConfig implements SocialConfigurer {

}

2、在SocialConfig中添加已注册的ConnectionFactoryLocator，这里使用的是Facebook，如果是其他平台的可以继续添加


@Override
public void addConnectionFactories(ConnectionFactoryConfigurer connectionFactoryConfigurer,
 Environment environment) {
 connectionFactoryConfigurer.addConnectionFactory(new FacebookConnectionFactory(
 environment.getProperty("facebook.appKey"), environment.getProperty("facebook.appSecret")));
}

3、在SocialConfig中添加UsersConnectionRepository以在所有用户之间保留连接数据


@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
 JdbcUsersConnectionRepository repository = new JdbcUsersConnectionRepository(dataSource,
 connectionFactoryLocator, Encryptors.noOpText());

 repository.setConnectionSignUp(new SimpleConnectionSignUp());
 return repository;
}

4、在SocialConfig中添加getUserIdSource以识别当前用户的连接


@Override
public UserIdSource getUserIdSource() {
 return new AuthenticationNameUserIdSource();
}

5、在SocialConfig中添加一个或多个表示当前用户API绑定的请求范围的bean。这里添加的是Facebook：


@Bean
@Scope(value = "request", proxyMode = ScopedProxyMode.INTERFACES)
public Facebook facebook(ConnectionRepository repository) {
 Connection<Facebook> connection = repository.findPrimaryConnection(Facebook.class);
 if (connection != null) {
 return connection.getApi();
 }

 return null;
}

6、在SocialConfig中添加ProviderSignInController，允许用户使用其提供者帐户登录


@Bean
public ProviderSignInController providerSignInController(ConnectionFactoryLocator connectionFactoryLocator,
 UsersConnectionRepository usersConnectionRepository) {
 return new ProviderSignInController(connectionFactoryLocator, usersConnectionRepository,
 new SpringSecuritySignInAdapter());
}

创建视图

创建一个"链接"视图，允许用户使用其提供者帐户登录，视图分别如下
connect/connectFacebook.html


<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">

<head>
 <meta charset="UTF-8">
 <title>连接到Facebook</title>
</head>

<body>
 <h3>连接到Facebook</h3>
 <form th:action="@{/signin/facebook}" method="POST">
 <input type="hidden" name="scope" value="email,user_friends" />
 <input type="hidden" name="redirect_uri" value="http://localhost:8080/connected/facebook" />
 <div class="formInfo">
 <p>你还没有连接到Facebook，点击连接按钮连接到Facebook账户</p>
 </div>
 <p>
 <button type="submit">连接到Facebook</button>
 </p>
 </form>
</body>

</html>

connected/connectFacebook.html


<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">

<head>
 <meta charset="UTF-8">
 <title>已连接到Facebook</title>
</head>

<body>
 <h3>已连接到Facebook</h3>
 <div class="formInfo">
 <p>你已连接到Facebook，点击连接按钮连接到Facebook账户</p>
 </div>
 <h3>Facebook好友: <span th:text="${friendsNum}"></span></h3>
 <ul>
 <li th:each="friend : ${friends}">
 <img th:src="'http://graph.facebook.com/' + ${friend.id} + '/picture'" align="middle" />
 <span th:text="${friend.name}">name</span>
 </li>
 </ul>
 <h3>邮箱信息: <span th:text="${email}"></span></h3>
</body>

</html>

调用API

最后，@Inject引用API绑定到需要它们的对象。检索当前用户的facebook好友的示例@Controller如下所示：


@Controller
public class SocialController {
 private Facebook facebook;
 private ConnectionRepository connectionRepository;

 @Inject
 public SocialController(Facebook facebook, ConnectionRepository connectionRepository) {
 this.facebook = facebook;
 this.connectionRepository = connectionRepository;
 }

 @RequestMapping(value = "/connect/facebook", method = RequestMethod.GET)
 public ModelAndView connectFacebook(Model model) {
 ModelAndView mv = new ModelAndView("connect/connectFacebook");
 mv.addObject("email", "[email protected]");
 return mv;
 }

 @RequestMapping(value = "/connected/facebook", method = RequestMethod.GET)
 public String connectedFacebook(Model model) {
 Connection<Facebook> connection = this.connectionRepository.findPrimaryConnection(Facebook.class);

 if (connection == null) {
 return "redirect:/connect/facebook";
 }

 List<Reference> friends = facebook.friendOperations().getFriends();

 String[] fields = { "id", "email", "first_name", "last_name" };
 User userProfile = facebook.fetchObject("me", User.class, fields);

 System.out.println(friends.size());
 model.addAttribute("friends", friends);
 model.addAttribute("friendsNum", friends.size());
 model.addAttribute("email", userProfile.getEmail());
 return "connect/connectedFacebook";
 }

}

经过以上几个流程最终就完成了相关的配置，可以启动项目进行测试了链接了。

仔细看下面这部分的内容，目前网上使用官网的例子经常遇到的错误及一些疑惑，经过本次的调整，一下问题都会得到解决。可以下载本实例进行测试


git clone https://github.com/durban89/spring-demo.git
git checkout v1.0.5

第一个疑惑

我们没有添加signin开头的路由为什么能请求的到呢，在项目启动的时候，其实这些已经跟在依赖包内做了处理了，这个在项目启动的时候让我豁然开朗


2018-07-18 11:20:55.878 INFO 66154 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/signin/{providerId}],methods=[POST]}" onto public org.springframework.web.servlet.view.RedirectView org.springframework.social.connect.web.ProviderSignInController.signIn(java.lang.String,org.springframework.web.context.request.NativeWebRequest)
2018-07-18 11:20:55.879 INFO 66154 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/signin/{providerId}],methods=[GET],params=[oauth_token]}" onto public org.springframework.web.servlet.view.RedirectView org.springframework.social.connect.web.ProviderSignInController.oauth1Callback(java.lang.String,org.springframework.web.context.request.NativeWebRequest)
2018-07-18 11:20:55.880 INFO 66154 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/signin/{providerId}],methods=[GET],params=[code]}" onto public org.springframework.web.servlet.view.RedirectView org.springframework.social.connect.web.ProviderSignInController.oauth2Callback(java.lang.String,java.lang.String,org.springframework.web.context.request.NativeWebRequest)
2018-07-18 11:20:55.903 INFO 66154 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/signin/{providerId}],methods=[GET],params=[error]}" onto public org.springframework.web.servlet.view.RedirectView org.springframework.social.connect.web.ProviderSignInController.oauth2ErrorCallback(java.lang.String,java.lang.String,java.lang.String,java.lang.String,org.springframework.web.context.request.NativeWebRequest)
2018-07-18 11:20:55.904 INFO 66154 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/signin/{providerId}],methods=[GET]}" onto public org.springframework.web.servlet.view.RedirectView org.springframework.social.connect.web.ProviderSignInController.canceledAuthorizationCallback()

第二个疑惑


org.springframework.web.client.ResourceAccessException: I/O error on POST request for "https://graph.facebook.com/v2.5/oauth/access_token": Operation timed out (Connection timed out); nested exception is java.net.ConnectException: Operation timed out (Connection timed out)

为什么我在国内配置完之后，也跳转到了社交平台，但是返回的时候报下面的错误

这个问题的解决方案如下
pom.xml文件添加类似如下的配置


<jvmArguments> -Dhttps.proxyHost=127.0.0.1 -Dhttps.proxyPort=1087 -Dhttp.proxyHost=127.0.0.1 -Dhttp.proxyPort=1087 -Dhttps.proxySet=true
</jvmArguments>

添加后的结果如下


<build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 <configuration>
 <jvmArguments> -Dhttps.proxyHost=127.0.0.1 -Dhttps.proxyPort=1087 -Dhttp.proxyHost=127.0.0.1 -Dhttp.proxyPort=1087 -Dhttps.proxySet=true
 </jvmArguments>
 </configuration>
 </plugin>
 </plugins>
</build>

其实就是做了代理的设置

第三个疑问


org.springframework.jdbc.BadSqlGrammarException: PreparedStatementCallback; bad SQL grammar [select userId from UserConnection where providerId = ? and providerUserId = ?]; nested exception is org.h2.jdbc.JdbcSQLException: Table "USERCONNECTION" not found; SQL statement:

为什么会提示我数据库表没有呢，不应该是自动为我建立吗，经过网上的查找，确实是没有自动帮你建立，这个需要自己去添加，可能这块的业务逻辑不能耦合的太紧密的原因吧
解决方案在这里
config/MainConfig.java


@Configuration
@ComponentScan(basePackages = "com.gowhich.springdemo", excludeFilters = { @Filter(Configuration.class) })
@PropertySource("classpath:application.properties")
public class MainConfig {

 @Bean(destroyMethod = "shutdown")
 public DataSource dataSource() {
 EmbeddedDatabaseFactory factory = new EmbeddedDatabaseFactory();
 factory.setDatabaseName("springdemo");
 factory.setDatabaseType(EmbeddedDatabaseType.H2);
 factory.setDatabasePopulator(databasePopulator());
 return factory.getDatabase();
 }

 private DatabasePopulator databasePopulator() {
 ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
 populator.addScript(
 new ClassPathResource("JdbcUsersConnectionRepository.sql", JdbcUsersConnectionRepository.class));
 return populator; }
}

同时别忘记创建JdbcUsersConnectionRepository.sql这个文件，放在src/main/resources目录下就可以。然后在运行项目就会自动创建数据库表了。
JdbcUsersConnectionRepository.sql
内容如下，github也有的。


create table UserConnection
(
 userId varchar(255) not null,
 providerId varchar(255) not null,
 providerUserId varchar(255),
 rank int not null,
 displayName varchar(255),
 profileUrl varchar(512),
 imageUrl varchar(512),
 accessToken varchar(1024) not null,
 secret varchar(255),
 refreshToken varchar(255),
 expireTime bigint,
 primary key (userId, providerId, providerUserId)
);
create unique index UserConnectionRank on UserConnection(userId, providerId, rank);

create table UserProfile
(
 userId varchar(255) not null,
 email varchar(255),
 firstName varchar(255),
 lastName varchar(255),
 name varchar(255),
 username varchar(255),
 primary key (userId)
);
create unique index UserProfilePK on UserProfile(userId);

第四个疑问


java.lang.IllegalStateException: No user is currently signed in

这个问题主要原因是官网的例子中使用的是TheadLocal，通过进程的方法共享数据，结果这个数据在再次获取的时候丢失了，具体原因我只查到在使用Spring Cloud的时候回遇到，没查到在使用Spring Boot的时候也会有，但是问题已解决，就是替换下，我这里的实例使用的是官网最新的文档中介绍的，在setCurrentUser和getCurrentUser的逻辑中做了修改，替换了TheadLocal。
修改的地方大概有几个地方，如下

获取用户数据的地方


@Override
public UserIdSource getUserIdSource() {
 return new AuthenticationNameUserIdSource();
}

注册用户数据的地方，改用了SecurityContextHolder的方式


@Bean
public ProviderSignInController providerSignInController(ConnectionFactoryLocator connectionFactoryLocator,
 UsersConnectionRepository usersConnectionRepository) {
 return new ProviderSignInController(connectionFactoryLocator, usersConnectionRepository,
 new SpringSecuritySignInAdapter());
}

和


public final class SpringSecuritySignInAdapter implements SignInAdapter {

 public String signIn(String userId, Connection<?> connection, NativeWebRequest request) {
 SecurityContextHolder.getContext()
 .setAuthentication(new UsernamePasswordAuthenticationToken(userId, null, null));
 return null;
 }

}

第五个疑问


org.springframework.social.UncategorizedApiException: (#12) bio field is deprecated for versions v2.8 and higher

这个是Facebook对应库版本不兼容的问题，这个网上还是很好找的
问题主要出在这里


List<Reference> friends = facebook.friendOperations().getFriends();

String[] fields = { "id", "email", "first_name", "last_name" };
User userProfile = facebook.fetchObject("me", User.class, fields);

官网的例子一般是只给出了这个


List<Reference> friends = facebook.friendOperations().getFriends();

当我们想要调用其他数据的时候比如用户信息"facebook.userOperations()“这样调用的时候就会报错，实际上就是不支持了，要换，换成如下的方式


String[] fields = { "id", "email", "first_name", "last_name" };
User userProfile = facebook.fetchObject("me", User.class, fields);

OK，埰坑完毕。期待我下次的分享，埰坑踩到无法呼吸。

实践项目地址


git clone https://github.com/durban89/spring-demo.git
git checkout v1.0.5

Spring boot基础学习记录之使用Facebook注册一个应用

Tue, 29 Jul 2025 10:08:53 +0800

实践环境


IDE
 Intellij IDEA[优点：自动安装新加依赖库]
JAVA
 java version "1.8.0_121"
 Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
 Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

实践项目初始化

我们以之前的项目为例，

地址:


https://github.com/durban89/spring-demo.git
tag: v1.0.3

官网的例子已经废弃了，这里还是说下整体的思路，截止今天2018-07-17，再有读者去官网如果还是看到这个例子，请不要在继续埰坑了，我已经踩雷了。而且一身的大粪。
不管是你在官网还是自己参照官网做了实例，最终都会报这个错误，错误的信息类似如下

Caused by: org.springframework.web.client.ResourceAccessException: I/O error on POST request for “https://graph.facebook.com/v2.5/oauth/access_token”: Operation timed out (Connection timed out); nested exception is java.net.ConnectException: Operation timed out (Connection timed out)

我这里只演示一个具体使用的思路，如果是在其他的第三方注册应用的话，应该如何使用
Spring中首先是要加入需要的依赖库，这里我使用的是maven，如果想使用gradle的话，可以去官网参考下。https://spring.io/guides/gs/register-facebook-app/
pom.xml添加如下文件


<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-facebook</artifactId>
 <version>2.0.3.RELEASE</version>
</dependency>
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-core</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.security</groupId>
 <artifactId>spring-security-crypto</artifactId>
</dependency>

这里注意下


<dependency>
 <groupId>org.springframework.social</groupId>
 <artifactId>spring-social-facebook</artifactId>
 <version>2.0.3.RELEASE</version>
</dependency>

这里的引用，记得加下版本号，我在没有添加版本号的情况下，IntelliJ IDEA并没有自动安装此依赖库
然后创建文件内容如下


package com.gowhich.springdemo;

import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.social.facebook.api.Facebook;
import org.springframework.social.facebook.api.impl.FacebookTemplate;
import org.springframework.social.facebook.connect.FacebookConnectionFactory;
import org.springframework.social.oauth2.OAuth2Operations;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import javax.swing.*;

@Controller
public class SocialController {
 @GetMapping("social/facebook")
 public void facebook() {
 String appId = "xxx"; //promptForInput("输入App ID:");
 String appSecret = "xxx"; // promptForInput("输入App Secret:");
 String appToken = fetchApplicationAccessToken(appId, appSecret);
 AppDetail appDetail = fetchApplicationData(appId, appToken);
 System.out.println("\n 应用详情");
 System.out.println("=====================");
 System.out.println("ID:" + appDetail.getId());
 System.out.println("Name:" + appDetail.getName());
 System.out.println("Namespace: "+appDetail.getNamespace());
 System.out.println("Contact Email:"+appDetail.getContactEmail());
 System.out.println("Website Url:"+appDetail.getWebsiteUrl());
 }

 private static AppDetail fetchApplicationData(String appId, String appToken) {
 Facebook facebook = new FacebookTemplate(appToken);
 return facebook.restOperations().getForObject(
 "https://graph.facebook.com/{appId}?fields=name,namespace,contact_email,website_url",
 AppDetail.class,
 appId);
 }

 private static String fetchApplicationAccessToken(String appId, String appSecret) {
 OAuth2Operations oauth = new FacebookConnectionFactory(appId, appSecret).getOAuthOperations();
 return oauth.authenticateClient().getAccessToken();
 }

 private static String promptForInput(String promptText) {
 return JOptionPane.showInputDialog(promptText + " ");
 }

 private static final class AppDetail {
 private long id;
 private String name;
 private String namespace;

 @JsonProperty("contact_email")
 private String contactEmail;

 @JsonProperty("website_url")
 private String websiteUrl;

 public long getId() {
 return id;
 }

 public String getName() {
 return name;
 }

 public String getNamespace() {
 return namespace;
 }

 public String getContactEmail() {
 return contactEmail;
 }

 public String getWebsiteUrl() {
 return websiteUrl;
 }
 }

}

基础逻辑其实很清楚的


String appToken = fetchApplicationAccessToken(appId, appSecret);

这行就是获取accessToken，通过请求Facebook的接口，根据appId和appSecret来获取AccessToken


AppDetail appDetail = fetchApplicationData(appId, appToken);

这行代码意思通过获取的accessToken来获取指定接口需要的指定数据，这里的话就是获取应用本身的数据。实际测试的时候出现了问题，就是应用还没有走到这一步，在获取token的时候就已经出问题了。这个先不管，后面我做个解决方案在分享给大家。
从代码中还可以看到有一个promptForInput方法，这个我觉得官方挺奇怪的，不知道为什么突然调用了java UI的弹窗，不是web的alert之类的UI，这个别搞混，我是搞迷糊了，以为也可以弹出来，结果各种埰坑，最后弃用了。其实可以自己做一个web的输入框

AppDetail这个用来存储获取的数据的，从例子上看的话应该是会返回一个json的数据，这里就测试不到了，比较囧。

期待我下次的分享，埰坑踩到无法呼吸。

项目地址


https://github.com/durban89/spring-demo.git
tag: v1.0.4

Spring Boot基础学习记录之使用LDAP对用户进行身份验证

Tue, 29 Jul 2025 10:08:50 +0800

实践环境


IDE
 Intellij IDEA[优点：自动安装新加依赖库]
JAVA
 java version "1.8.0_121"
 Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
 Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

实践项目初始化

我们以之前的项目为例，

地址:


https://github.com/durban89/spring-demo.git
tag: v1.0.2

创建一个简单的web controller

代码如下

src/main/java/com/gowhich/springdemo/HomeController.java


package com.gowhich.springdemo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HomeController {
 @GetMapping("/home")
 public String index() {
 return "欢迎来到Home页面";
 }
}

配置Spring Security

Maven配置，添加如下依赖


<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.ldap</groupId>
 <artifactId>spring-ldap-core</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.security</groupId>
 <artifactId>spring-security-ldap</artifactId>
</dependency>
<dependency>
 <groupId>com.unboundid</groupId>
 <artifactId>unboundid-ldapsdk</artifactId>
</dependency>

<dependency>
 <groupId>org.springframework.security</groupId>
 <artifactId>spring-security-test</artifactId>
 <scope>test</scope>
</dependency>

创建WebSecurityConfig.java

代码如下

src/main/java/com/gowhich/springdemo/WebSecurityConfig.java


package com.gowhich.springdemo;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.LdapShaPasswordEncoder;

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

 @Override
 public void configure(AuthenticationManagerBuilder auth) throws Exception {
 auth.ldapAuthentication()
 .userDnPatterns("uid={0},ou={people}")
 .groupSearchBase("ou=groups")
 .contextSource()
 .url("ldap://localhost:8389/dc=springframework,dc=org")
 .and()
 .passwordCompare()
 .passwordEncoder(new LdapShaPasswordEncoder())
 .passwordAttribute("userPassword");
 }

 @Override
 protected void configure(HttpSecurity http) throws Exception {
 http.authorizeRequests().anyRequest().fullyAuthenticated().and().formLogin();
 }
}

application.properties配置

添加如下内容


spring.ldap.embedded.ldif=classpath:test-server.ldif
spring.ldap.embedded.base-dn=dc=springframework,dc=org
spring.ldap.embedded.port=8389

添加src/main/resources/test-server.ldif

内容如下


dn: dc=springframework,dc=org
objectclass: top
objectclass: domain
objectclass: extensibleObject
dc: springframework

dn: ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: groups

dn: ou=subgroups,ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: subgroups

dn: ou=people,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: people

dn: ou=space cadets,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: space cadets

dn: ou=\"quoted people\",dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: "quoted people"

dn: ou=otherpeople,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: otherpeople

dn: uid=ben,ou=people,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Ben Alex
sn: Alex
uid: ben
userPassword: {SHA}nFCebWjxfaLbHHG1Qk5UU4trbvQ=

dn: uid=bob,ou=people,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Bob Hamilton
sn: Hamilton
uid: bob
userPassword: bobspassword

dn: uid=joe,ou=otherpeople,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Joe Smeth
sn: Smeth
uid: joe
userPassword: joespassword

dn: cn=mouse\, jerry,ou=people,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Mouse, Jerry
sn: Mouse
uid: jerry
userPassword: jerryspassword

dn: cn=slash/guy,ou=people,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: slash/guy
sn: Slash
uid: slashguy
userPassword: slashguyspassword

dn: cn=quote\"guy,ou=\"quoted people\",dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: quote\"guy
sn: Quote
uid: quoteguy
userPassword: quoteguyspassword

dn: uid=space cadet,ou=space cadets,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Space Cadet
sn: Cadet
uid: space cadet
userPassword: spacecadetspassword

dn: cn=developers,ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: groupOfUniqueNames
cn: developers
ou: developer
uniqueMember: uid=ben,ou=people,dc=springframework,dc=org
uniqueMember: uid=bob,ou=people,dc=springframework,dc=org

dn: cn=managers,ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: groupOfUniqueNames
cn: managers
ou: manager
uniqueMember: uid=ben,ou=people,dc=springframework,dc=org
uniqueMember: cn=mouse\, jerry,ou=people,dc=springframework,dc=org

dn: cn=submanagers,ou=subgroups,ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: groupOfUniqueNames
cn: submanagers
ou: submanager
uniqueMember: uid=ben,ou=people,dc=springframework,dc=org

启动项目后访问localhost:8080

会跳转到被Spring Security提供的登录页面，输入用户名"ben"和密码"benspassword".然后就能继续访问所有的页面，比如localhost:8080/home，会得到如下输出


Welcome to the home page!

项目地址


https://github.com/durban89/spring-demo.git
tag: v1.0.3

Spring Boot基础学习记录之Uploading Files(上传文件)部分代码解惑

Mon, 28 Jul 2025 17:52:39 +0800

实践环境


IDE
 Intellij IDEA[优点：自动安装新加依赖库]
JAVA
 java version "1.8.0_121"
 Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
 Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

实践项目

地址:


https://github.com/durban89/spring-demo.git

tag: v1.0.1

上次写了篇文章。大概是按照官网的例子做了下如何上传文件，这里温故下里面的细节代码部分

主要说下storage部分的代码 src/main/java/com/gowhich/springdemo/storage


├── FileSystemStorageService.java
├── StorageException.java
├── StorageFileNotFoundException.java
├── StorageProperties.java
└── StorageService.java

总的来说五个文件

StorageService.java接口定义
FileSystemStorageService.java上面接口方法实现
StorageProperties.java存储的属性的定义
StorageException.java
StorageFileNotFoundException.java

一个接口类，一个接口实现类，两个异常类，异常类没啥说的

StorageProperties.java这个类中，注意下


@ConfigurationProperties("storage")

这段代码，这段代码加入后，还需要在启动类文件SpringDemoApplication.java中加入


@EnableConfigurationProperties(StorageProperties.class)

这段代码，不然会出问题，这个特性还是很诱人的，具体原理还望指点

StorageService.java这个类很好理解，就是一些关于存储相关的方法，具体的还是要看实现部分，来分析下FileSystemStorageService.java这个文件，这个文件注意需要加入@Service注解，便于后面的调用能自动找到对应的实现部分。


public class FileSystemStorageService implements StorageService {
 private final Path rootLocation;

 @Autowired
 public FileSystemStorageService(StorageProperties properties) {
 this.rootLocation = Paths.get(properties.getLocation());
 }

 @Override
 public void init() { // 这部分初始化创建目录
 try {
 Files.createDirectories(rootLocation);
 } catch (IOException ex) {
 throw new StorageException("初始化存储空间失败", ex);
 }

 }

 @Override
 public void store(MultipartFile file) { // 这部分根据提交的文件来上传并存储到本地
 String filename = StringUtils.cleanPath(file.getOriginalFilename());
 try {
 if (filename.isEmpty()) {
 throw new StorageException("存储文件"+filename+"失败");
 }

 if (filename.contains("..")) {
 throw new StorageException("不能存储当前路径以外的文件"+filename);
 }

 try (InputStream inputStream = file.getInputStream()) {
 Files.copy(inputStream, this.rootLocation.resolve(filename), StandardCopyOption.REPLACE_EXISTING);
 }
 } catch (IOException ex) {
 throw new StorageException("存储文件"+filename+"失败", ex);
 }
 }

 @Override
 public Stream<Path> loadAll() { // 这部分加载目录下所有的文件
 try {
 return Files.walk(this.rootLocation, 1)
 .filter(path -> !path.equals(this.rootLocation))
 .map(this.rootLocation::relativize);
 } catch (IOException ex) {
 throw new StorageException("读取存储文件失败", ex);
 }
 }

 @Override
 public Path load(String filename) { // 这部分加载目录下某个文件
 return rootLocation.resolve(filename);
 }

 @Override
 public Resource loadAsResource(String filename) { // 这部分加载目录下某个文件的资源
 try {
 Path file = load(filename);
 Resource resource = new UrlResource(file.toUri());
 if (resource.exists() || resource.isReadable()) {
 return resource;
 } else {
 throw new StorageFileNotFoundException("不能读取文件" + filename);
 }
 } catch (MalformedURLException ex) {
 throw new StorageFileNotFoundException("不能读取文件" + filename, ex);
 }
 }

 @Override
 public void deleteAll() {
 FileSystemUtils.deleteRecursively(rootLocation.toFile());
 }

}

实现上并不难，难得是如何自己不看官网的例子，自己也能写一个出来，充分理解里面的逻辑。

存储部分实现后需要在启动类文件中加入初始化需要做的事情


@Bean
CommandLineRunner init(StorageService storageService) {
 return (args) -> {
 storageService.deleteAll();
 storageService.init();
 };
}

删除目录下的原有的文件，并创建目录【如果目录不存在的话】

在FileUploadController.java中有一部分


@ExceptionHandler({StorageFileNotFoundException.class})
public ResponseEntity<?> handleStorageFileNotFound(StorageFileNotFoundException ex) {
 return ResponseEntity.notFound().build();
}

异常处理，如果在操作过程中遇到异常的话，会进行异常的统一处理，这里有个中文乱码的问题，后面我找到办法在详细记录。

Spring Boot基础学习记录之Uploading Files(上传文件)

Mon, 28 Jul 2025 17:52:36 +0800

实践环境


IDE

 Intellij IDEA[优点：自动安装新加依赖库]

JAVA

 java version "1.8.0_121"

 Java(TM) SE Runtime Environment (build 1.8.0_121-b13)

 Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

实践项目初始化

我们以之前的项目为例，

地址:


https://github.com/durban89/spring-demo.git

tag: v1.0.1

Maven配置

pom.xml添加下面的依赖库，主要是后面的页面以thymeleaf作为模板


<dependency>

 <groupId>org.springframework.boot</groupId>

 <artifactId>spring-boot-starter-thymeleaf</artifactId>

</dependency>

创建StorageService与存储层进行交互，如"文件系统"

src/main/java/com/gowhich/springdemo/StorageService.java


package com.gowhich.springdemo.storage;

import org.springframework.core.io.Resource;
import org.springframework.web.multipart.MultipartFile;

import java.nio.file.Path;
import java.util.stream.Stream;

public interface StorageService {

 void init();

 void store(MultipartFile file);

 Stream<Path> loadAll();

 Path load(String filename);

 Resource loadAsResource(String filename);

 void deleteAll();
}

***创建了存储层就要实现对接接口方法的实现，具体的可以拉取项目看下

创建上传文件的控制器

src/main/java/com/gowhich/springdemo/FileUploadController.java


package com.gowhich.springdemo;

import com.gowhich.springdemo.storage.StorageFileNotFoundException;
import com.gowhich.springdemo.storage.StorageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder;
import org.springframework.core.io.Resource;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import java.io.IOException;
import java.util.stream.Collectors;

@Controller
public class FileUploadController {
 private final StorageService storageService;

 @Autowired
 public FileUploadController(StorageService storageService) {
 this.storageService = storageService;
 }

 @GetMapping("/")
 public String listUploadedFiles(Model model) throws IOException {
 model.addAttribute("files", storageService.loadAll().map(
 path -> MvcUriComponentsBuilder.fromMethodName(FileUploadController.class,
 "serveFile", path.getFileName().toString()).build().toString())
 .collect(Collectors.toList()));

 return "uploadForm";
 }

 @GetMapping("/files/{filename:.+}")
 @ResponseBody
 public ResponseEntity<Resource> serveFile(@PathVariable String filename) {
 Resource resource = storageService.loadAsResource(filename);
 return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION,
 "attachment; filename=\"" + resource.getFilename() + "\"").body(resource);
 }

 @PostMapping("/")
 public String handleFileUpload(@RequestParam("file")MultipartFile file, RedirectAttributes redirectAttributes) {
 storageService.store(file);
 redirectAttributes.addFlashAttribute("message", "成功上传了文件 " + file.getOriginalFilename() + "!");
 return "redirect:/";
 }

 @ExceptionHandler({StorageFileNotFoundException.class})
 public ResponseEntity<?> handleStorageFileNotFound(StorageFileNotFoundException ex) {
 return ResponseEntity.notFound().build();
 }
}

创建一个HTML模板

src/main/java/com/gowhich/springdemo/src/main/resources/templates/uploadForm.html


<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>UploadForm</title>
</head>
<body>
 <div th:if="${message}">
 <h2 th:text="${message}"/>
 </div>

 <div>
 <form method="post" enctype="multipart/form-data" action="/">
 <table>
 <tr>
 <td>
 File to upload:
 </td>
 <td>
 <input type="file" name="file" />
 </td>
 </tr>
 <tr>
 <td></td>
 <td>
 <input type="submit" value="上传" />
 </td>
 </tr>
 </table>
 </form>
 </div>
 <div>
 <ul>
 <li th:each="file: ${files}">
 <a th:href="${file}" th:text="${file}" />
 </li>
 </ul>
 </div>
</body>
</html>

调整文件上传限制

src/main/resources/application.properties中添加


spring.servlet.multipart.max-file-size=128KB

spring.servlet.multipart.max-request-size=128KB

spring.servlet.multipart.enabled=true

spring.http.encoding.charset=UTF-8

Application配置

src/main/java/com/gowhich/springdemo/SpringDemoApplication.java修改如下


package com.gowhich.springdemo;

import com.gowhich.springdemo.storage.StorageProperties;
import com.gowhich.springdemo.storage.StorageService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;

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

 @Bean
 CommandLineRunner init(StorageService storageService) {
 return (args) -> {
 storageService.deleteAll();
 storageService.init();
 };
 }
}

启动项目，我在Intellij IDEA直接可以操作启动，很方便

项目地址


https://github.com/durban89/spring-demo.git

tag: v1.0.2

Spring Boot基础学习记录之使用JDBC访问关系数据

Mon, 28 Jul 2025 17:52:31 +0800

1、依赖添加


<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
 <groupId>com.h2database</groupId>
 <artifactId>h2</artifactId>
</dependency>

2、mav自动安装依赖，如果没有的话，请检查

3、创建对象Customer


package com.gowhich.springdemo;
public class Customer {
 private long id;
 private String firstName, lastName;
 public Customer(long id, String firstName, String lastName) {
 this.id = id;
 this.firstName = firstName;
 this.lastName = lastName;
 }
 @Override
 public String toString() {
 return String.format("Customer[id=%d, firstName=%s, lastName=%s]", id, firstName, lastName);
 }
}

这个对象可以理解为Model，就是要跟数据库表对应的关系

假设表customers有三个字段

id,first_name,last_name

id对应这里的Customer Model 的 id

first_name对应这里的Customer Model 的 firstName

last_name对应这里的Customer Model 的 lastName

4、修改Application.java[程序启动的入库文件，也许你的名字并不是这个]，如我的demo中是SpringDemoApplication.java，修改后的结果是


public class SpringDemoApplication implements CommandLineRunner {
	public static void main(String[] args) {
		SpringApplication.run(SpringDemoApplication.class, args);
	}
 // 创建日志
	private static final Logger log = LoggerFactory.getLogger(SpringDemoApplication.class);
 // 初始化JdbcTemplate 会自动连接h2database数据库
	@Autowired
 JdbcTemplate jdbcTemplate;
	@Override
 public void run(String... strings) throws Exception {
 log.info("Creating tables");
 // 创建表
 jdbcTemplate.execute("DROP TABLE customers IF EXISTS ");
 jdbcTemplate.execute("CREATE TABLE customers ("+
 "id SERIAL, first_name VARCHAR(255), last_name VARCHAR(255))");
 // 输入数据
 List<Object[]> splitUpNames = Arrays.asList("John Woo","Jeff Dean", "Josn Bokch", "Josh Long").stream()
 .map(name -> name.split(" ")).collect(Collectors.toList());
 splitUpNames.forEach(name -> log.info(String.format("Inserting customers record for %s %s", name[0], name[1])));
 jdbcTemplate.batchUpdate("INSERT INTO customers (first_name, last_name) VALUES (?, ?)", splitUpNames);
 // 查询数据
 log.info("Querying for customers records where first_name = 'Josh");
 jdbcTemplate.query(
 "SELECT id, first_name, last_name FROM customers WHERE first_name = ?",
 new Object[] {"Josh"},
 (rs, column) -> new Customer(rs.getLong("id"), rs.getString("first_name"), rs.getString("last_name")))
 .forEach(customer -> log.info(customer.toString()));
 }
}

5、启动项目

启动项目后，会看到如下的输出

Spring Boot基础之构建一个REST风格的Web服务

Mon, 28 Jul 2025 17:52:21 +0800

1、创建一个资源表示类

该服务将处理/playing的GET请求，可选地在查询字符串中使用名称参数。 GET请求时应该返回带有JSON的200 OK响应。它应该看起来像这样：

{
 "autokid": 1,
 "content": "Playing Football!"
}

autokid字段是唯一标识符

content是内容的文字表示

2、建模，创建一个资源表示类。

为autokid和content数据提供一个普通的java对象，其中包含字段，构造函数和访问器：

src/main/java/com/walkerfree/Playing.java

package com.walkerfree;
/**
 * Playing
 */
public class Playing {
 private final long autokid;
 private final String content;
 public Playing(long autokid, String content) {
 this.autokid = autokid;
 this.content = content;
 }
 /**
 * @return the autokid
 */
 public long getAutokid() {
 return autokid;
 }
 /**
 * @return the content
 */
 public String getContent() {
 return content;
 }
}

3、创建资源控制器

在Spring构建RESTful Web服务的方法中，HTTP请求由控制器处理。这些组件可以通过@RestController轻松识别，并且PlayingController通过返回Playing类的新实例来处理/playing的GET请求：

src/main/java/com/walkerfree/controller/PlayingController.java

package com.walkerfree.controller;
import java.util.concurrent.atomic.AtomicLong;
import com.walkerfree.Playing;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
 * PlayingController
 */
@RestController
public class PlayingController {
 private static final String template = "Playing %s!";
 private final AtomicLong atomic = new AtomicLong();
 @RequestMapping("/playing")
 public Playing playing(@RequestParam(value = "name", defaultValue = "Football") String name) {
 return new Playing(atomic.incrementAndGet(), String.format(template, name));
 }
}

这个控制器是比较简练的，但是它却做了很多事情，让我们一步一步分解它

@RequestMapping注解确保HTTP请求到/playing的时候能够映射到playing()方法

@RequestParam绑定了查询参数字符串的name参数到playing()方法中.如果请求的name参数不存在, 默认的“Football”将被使用

方法体的实现了带有autokid和content属性的Playing对象的返回，autokid是基于atomic生成值，content是模板格式化name后生成的字符串

重点：传统的MVC控制器和上面的RESTful Web服务控制器之间的一个主要区别在于HTTP响应主体的创建方式。这个RESTful Web服务控制器只需填充并返回一个Playing对象，而不是依赖视图技术将生成数据的服务器端呈现给HTML。对象数据将作为JSON直接写入HTTP响应。

此代码使用Spring 4的新的@RestController注释，该注释将类标记为控制器，其中每个方法都返回一个域对象而不是视图。它是@Controller和@ResponseBody的缩写。

Playing对象必须转换为JSON。由于Spring的HTTP消息转换器支持，您不需要手动执行此转换。由于Jackson 2位于类路径中，因此会自动选择Spring的MappingJackson2HttpMessageConverter将Playing实例转换为JSON。

4、运行代码

mvn spring-boot:run

访问http://localhost:8080/playing?name=pingpang会得到类似如下输出

{
 autokid: 3,
 content: "Playing pingpang!"
}

实例代码参考：https://github.com/durban89/simple_dynamic_webpage，tag:004

Spring Boot基础之调度任务

Mon, 28 Jul 2025 17:52:18 +0800

1、首先创建一个调度任务

src/main/java/com/walkerfree/ScheduledTasks.java


package com.walkerfree;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class ScheduledTasks {
 private static final Logger log = LoggerFactory.getLogger(ScheduledTasks.class);
 private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
 @Scheduled(fixedRate = 5000)
 public void reportCurrentTime() {
 log.info("The time is now {}", dateFormat.format(new Date()));
 }
}

@Scheduled注解定义了特定方法的运行时间。

此示例使用fixedRate，它指定从每次调用的开始时间开始测量的方法调用之间的时间间隔。

还有其他选项，比如fixedDelay，它指定了从任务完成之后测量的调用之间的时间间隔。

您还可以使用@Scheduled（cron =“…”）表达式来执行更复杂的任务计划。

2、启用调度任务

src/main/java/com/walkerfree/Application.java


package com.walkerfree;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

@SpringBootApplication是一个很方便的注释，它增加了以下所有内容：

1】@Configuration 将类标记为定义了应用程序上下文的bean资源。

2】@EnableAutoConfiguration 通知Spring Boot根据类路径设置，其他bean和各种属性设置来开始添加beans

3】通常情况下，会为Spring MVC应用程序添加@EnableWebMvc，但Spring Boot在类路径中看到spring-webmvc时自动添加它。这将该应用程序标记为Web应用程序并激活关键行为，例如设置DispatcherServlet。

4】@ComponentScan告诉Spring在com.walkerfree包中查找其他组件，配置和服务，以便找到控制器。

main()方法使用Spring Boot的SpringApplication.run()方法启动应用程序。你有没有注意到没有一行XML？没有web.xml文件。这个Web应用程序是100％纯Java，您不必处理配置任何管道或基础设施。

@EnableScheduling确保创建后台任务执行程序。没有它调度任务不会执行

3、运行项目


mvn spring-boot:run

留意日志的输入，会有如下的输出


2018-04-27 11:38:11.572 INFO 11747 --- [pool-1-thread-1] com.walkerfree.ScheduledTasks : The time is now 11:38:11
2018-04-27 11:38:16.571 INFO 11747 --- [pool-1-thread-1] com.walkerfree.ScheduledTasks : The time is now 11:38:16
2018-04-27 11:38:21.572 INFO 11747 --- [pool-1-thread-1] com.walkerfree.ScheduledTasks : The time is now 11:38:21
2018-04-27 11:38:26.572 INFO 11747 --- [pool-1-thread-1] com.walkerfree.ScheduledTasks : The time is now 11:38:26

实例代码参考：https://github.com/durban89/simple_dynamic_webpage，tag:003

Spring Boot基础之数据库连接

Mon, 28 Jul 2025 17:52:15 +0800

1、首先配置下我们连接数据库需要的包

第一个需要的是

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

第二个需要的是

<dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
</dependency>

将上面两个依赖加入到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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.walkerfree</groupId>
 <artifactId>simple_dynamic_webpage</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
 </parent>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-freemarker</artifactId>
 </dependency>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 </dependencies>
 <properties>
 <java.version>1.8</java.version>
 </properties>
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>
</project>

2、创建application.properties文件

创建一个文件src/main/resources/application.properties，添加如下内容

spring.jpa.hibernate.ddl-auto=create
spring.datasource.url=jdbc:mysql://localhost:3306/db_example
spring.datasource.username=username
spring.datasource.password=password

spring.jpa.hibernate.ddl-auto这里的值可以是none,update,create,create-drop,具体的详情，请参阅Hibernate文档

none: 对于mysql这个是默认的，不需要对数据结构进行改变.

update: 根据Entity的结构，Hibernate改变了数据结构.

create: 每次都会创建数据库但是关闭的时候不会drop数据库.

create-drop: 创建数据库并且当SessionFactory关闭的时候drop数据库.

3、创建一个@Entity model

src/main/java/com/walkerfree/model/User.java

package com.walkerfree.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity // 这告诉Hibernate从这个类中创建一个表
public class User {
 @Id
 @GeneratedValue(strategy=GenerationType.AUTO)
 private Integer id;
 private String name;
 private String email;
 /**
 * @return the email
 */
 public String getEmail() {
 return email;
 }
 /**
 * @param email the email to set
 */
 public void setEmail(String email) {
 this.email = email;
 }
 /**
 * @return the id
 */
 public Integer getId() {
 return id;
 }
 /**
 * @param id the id to set
 */
 public void setId(Integer id) {
 this.id = id;
 }
 /**
 * @return the name
 */
 public String getName() {
 return name;
 }
 /**
 * @param name the name to set
 */
 public void setName(String name) {
 this.name = name;
 }
}

这是Hibernate自动转换成表的实体类。

4、创建repository

package com.walkerfree.repository;
import com.walkerfree.model.User;
import org.springframework.data.repository.CrudRepository;
/**
 * This will be AUTO IMPLEMENTED by Spring into a Bean called userRepository
 * CRUD refers Create, Read, Update, Delete
 */
public interface UserRepository extends CrudRepository<User, Long> {
}

5、创建一个controller，叫做UserController.java

package com.walkerfree.controller;
import com.walkerfree.model.User;
import com.walkerfree.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
/**
 * UserController
 */
@Controller // 这里的意思是这个类是一个控制器类
@RequestMapping("/user") // 这里的意思是 URL是/user开始的
public class UserController {
 @Autowired // 这里的意思是获得一个bean叫做userRepository，userRepository是Spring自动产生的，我们将用它来控制数据
 private UserRepository userRepository;
 @GetMapping(path = "/add") // 只Map到GET请求
 public @ResponseBody String addNewUser(@RequestParam String name, @RequestParam String email) {
 // @ResponseBody 意思是返回的String是一个响应体，不是一个视图的名称
 // @RequestParam 意思是从GET或POST请求的一个参数
 User u = new User();
 u.setName(name);
 u.setEmail(email);
 userRepository.save(u);
 return "Saved";
 }
 public @ResponseBody Iterable<User> getAllUsers() {
 return userRepository.findAll();
 }
}

@GetMapping是@RequestMapping(method=GET)的简写

6、运行项目

运行项目后，我们查看下我们的数据库，其实是自动帮我们建立了对应的表，大家可以留意下。当我们停掉项目再次重启项目时，数据库的表会自动被新建。

实例代码需要的话到这里：https://github.com/durban89/simple_dynamic_webpage，tag:002

Spring Boot基础之简单的动态页面实现

Mon, 28 Jul 2025 17:52:11 +0800

之前的文章已经写过如何实现一个简单的静态页面，这里简单介绍下如何写一个动态的页面，

这里已最简单为主，项目的常见我就不具体介绍了

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.walkerfree</groupId>
 <artifactId>simple_dynamic_webpage</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
 </parent>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-freemarker</artifactId>
 </dependency>
 </dependencies>
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>
</project>

Application.java

package com.walkerfree;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

WelcomeController.java

package com.walkerfree.controller;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * WelcomeController
 */
@Controller
public class WelcomeController {
 @RequestMapping("/")
 public String index(Model model) {
 // 这里我们设置动态数据 - 每访问页面一次，数据都会从服务器重新获取新的数据
 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-d HH:mm:ss");
 String dateString = df.format(new Date());
 model.addAttribute("time", dateString);
 return "welcome/index";
 }
}

目录结果如下

.
├── pom.xml
├── src
│ └── main
│ ├── java
│ │ └── com
│ │ └── walkerfree
│ │ ├── Application.java
│ │ └── controller
│ │ └── WelcomeController.java
│ └── resources
│ ├── public
│ └── templates
│ └── welcome
│ └── index.ftl
└── target

运行项目mvn spring-boot:run

访问页面我会看到一个动态变化的时间，如下

具体的代码可以去github上获取:https://github.com/durban89/simple_dynamic_webpage

只是一个简单的时间动态展示，后面会有个复杂一点的，比如一个简单的博客。再次之前我们还是要把一些基础的了解完。

Spring Boot基础之简单的路由配置

Mon, 28 Jul 2025 17:48:57 +0800

使用mavn创建项目我就不多说了，可以根据前面的历史文章进行操作，启动文件的内容我也不展示里，跟前面文章介绍的是一样的，这里介绍下路由具体使用，代码如下

创建一个文件UserController.java

package com.walkerfree.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
@RequestMapping("/user")
public class UserController {
 @RequestMapping(value="/{user}", method= RequestMethod.GET)
 public String getUser(@PathVariable Long user, Model model) {
 model.addAttribute("user", user);
 return "user/detail";
 }
 @RequestMapping(value = "/{user}/customers", method = RequestMethod.GET)
 public String getUserCustomers(@PathVariable Long user, Model model) {
 model.addAttribute("user", user);
 return "user/customer";
 }
 @RequestMapping(value="/{user}", method = RequestMethod.DELETE)
 public String deleteUser(@PathVariable Long user, Model model) {
 model.addAttribute("user", user);
 return "user/delete";
 }
}

可以看到

@RequestMapping(value="/{user}", method=RequestMethod.GET)

value对应的是访问的路径，method对应的是访问的方法配置

method支持的方法如下

DELETE

GET

HEAD

OPTIONS

PATCH

POST

PUT

TRACE

value="/{user}"

这里的{user}是个需要传出的参数值，如果你对其他框架熟悉的话，应该会比较容易理解

http://localhost:8080/user/1

这里的1就是对应的{user}这个参数，我们可以在模板中进行调用

@Controller
@RequestMapping("/user")

这里的"/user"其实是在所有方法中设置的路径的前面加上都会默认加入此路径，这个是比较好的，防止自己多次重复操作了。

由于这里使用了模板，所以还需要建立对应的模板，具体模板的目录resources结构如下

├── public
└── templates
 └── user
 ├── customer.ftl
 ├── delete.ftl
 └── detail.ftl

上面一切做完之后，启动项目就可以正常访问了

项目的代码我放在这里了需要的可以下载看下

https://github.com/durban89/spring_boot_simple_router_configuration

Spring Boot基础之自定义错误页面

Mon, 28 Jul 2025 17:48:53 +0800

自定义错误页面网上有很多种方式，我这里只介绍下我认为很高效的方法

直接在模板目录下建立对应错误状态码的页面，比如错误码是404，我们建立一个404.ftl页面放入目录中，目录结构如下

├── java
│ └── com
│ └── walkerfree
│ ├── Application.java
│ └── controller
│ └── WelcomeController.java
└── resources
 ├── public
 │ └── error
 │ └── 404.html
 ├── static
 └── templates
 ├── error
 │ └── 404.ftl
 └── welcome
 └── index.ftl

运行项目，在遇到404的时候就会访问到templates/error/404.ftl这个页面

从上面的目录可以发现resources/public目录下面也有对应的错误页面，如果我们删除templates/error下面的文件会发现，在遇到错误404的时候会自动调用public目录下面的错误页面

注：resources/templates/error/ 这个的优先级比较 resources/public/error/高

当然也有通过Controller实现的，具体的我们下次再介绍

WelcomeController.java 的内容如下

package com.walkerfree.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class WelcomeController {
 @RequestMapping("welcome/index")
 public String index(Model model) {
 model.addAttribute("title", "index");
 return "welcome/index";
 }
}

Application.java的代码如下

package com.walkerfree;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

项目参考地址：https://github.com/durban89/spring_boot_simple_custom_error_pages

Spring Boot基础之简单的模板配置使用

Mon, 28 Jul 2025 17:48:51 +0800

具体的项目创建这里不再介绍，可以参考之前的文章

这里先介绍下项目初始状态的目录结构

├── pom.xml
├── simple_page.iml
└── src
 └── main
 ├── java
 │ └── com
 │ └── gowhich
 │ └── Application.java
 └── resources
 └── static
 └── index.html

1、FreeMarker模板的使用

FreeMarker模板的使用很简单，默认就是被支持的

1) 修改pom.xml添加如下内容

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

最后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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.gowhich</groupId>
	<artifactId>simple_page</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<parent>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-parent</artifactId>
	 <version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
	 <dependency>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-web</artifactId>
	 </dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-freemarker</artifactId>
		</dependency>
	</dependencies>

	<build>
	 <plugins>
	 <plugin>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-maven-plugin</artifactId>
	 </plugin>
	 </plugins>
	</build>
</project>

2) 在resources目录下建立一个文件夹templates,在templates下面创建一个文件index.ftl,里面的内容如下

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>The FreeMarker Template Page</title>
</head>
<body>
<div>
 <center>The FreeMarker Template Page - ${title}</center>
</div>
</body>
</html>

3) 创建一个controller来调用我们创建的index.ftl

创建WelcomeController.java ，内容如下

package com.gowhich.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class WelcomeController {
 @RequestMapping("web/index")
 public String webIndex() {
 return "index";
 }
}

目录结构如下

├── pom.xml
├── simple_page.iml
└── src
 └── main
 ├── java
 │ └── com
 │ └── gowhich
 │ ├── Application.java
 │ └── controller
 │ └── WelcomeController.java
 └── resources
 ├── static
 │ └── index.html
 └── templates
 └── index.ftl

4) 运行项目，并访问http://localhost:8080/web/index，会得到如下输出

2、Thymeleaf模板的使用

1) 修改pom.xml添加如下内容

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

最后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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.gowhich</groupId>
	<artifactId>simple_page</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<parent>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-parent</artifactId>
	 <version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
	 <dependency>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-web</artifactId>
	 </dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-freemarker</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
	</dependencies>

	<build>
	 <plugins>
	 <plugin>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-maven-plugin</artifactId>
	 </plugin>
	 </plugins>
	</build>
</project>

2) 为了跟FreeMaker区分，在templates目录下建立一个目录thymeleaf，然后添加文件user.html，里面的内容如下

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title th:text="${title}"></title>
</head>
<body>
<div>
 <center th:text="${content}"></center>
</div>
</body>
</html>

3) 修改controller文件，WelcomeController.java ，变更后的内容如下

package com.gowhich.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class WelcomeController {
 @RequestMapping("/web/index")
 public String webIndex(Model model) {
 model.addAttribute("title", "Walkerfree");
 return "index";
 }
 @RequestMapping("/web/user")
 public String webUser(Model model) {
 model.addAttribute("title", "Walkerfree");
 model.addAttribute("content", "The FreeMarker Template Page - Walkerfree");
 return "thymeleaf/user";
 }
}

更改后的目录结构如下

├── pom.xml
├── simple_page.iml
└── src
 └── main
 ├── java
 │ └── com
 │ └── gowhich
 │ ├── Application.java
 │ └── controller
 │ └── WelcomeController.java
 └── resources
 ├── static
 │ └── index.html
 └── templates
 ├── index.ftl
 └── thymeleaf
 └── user.html

运行项目，并访问http://localhost:8080/web/user，会得到如下输出

Spring Boot 基础之简单的静态页面实现

Mon, 28 Jul 2025 17:48:47 +0800

1、使用maven创建Spring Boot Application [gradle的实现版本可以参考之前的文章]

项目根目录创建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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.gowhich</groupId>
	<artifactId>simple_page</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<parent>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-parent</artifactId>
	 <version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
	 <dependency>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-web</artifactId>
	 </dependency>
	</dependencies>

	<build>
	 <plugins>
	 <plugin>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-maven-plugin</artifactId>
	 </plugin>
	 </plugins>
	</build>
</project>

2、创建目录src/main/java

mkdir -p src/main/java

3、添加项目启动文件

启动文件Application.java 内容如下

package com.gowhich;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

整体的目录结构如下

4、创建目录src/main/resources/static

在static目录下创建index.html文件，内容如下

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>Simple Static Page</title>
</head>
<body>
 <div>
 <center>Simple Static Page</center>
 </div>
</body>
</html>

5、启动项目

mvn spring-boot:run

得到如下输出代表启动成功

[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< com.gowhich:simple_page >-----------------------
[INFO] Building simple_page 0.0.1-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] >>> spring-boot-maven-plugin:2.0.0.RELEASE:run (default-cli) > test-compile @ simple_page >>>
[INFO]
[INFO] --- maven-resources-plugin:3.0.1:resources (default-resources) @ simple_page ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 0 resource
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:compile (default-compile) @ simple_page ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /xxxxx/java/simple-page/target/classes
[INFO]
[INFO] --- maven-resources-plugin:3.0.1:testResources (default-testResources) @ simple_page ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /xxxxx/java/simple-page/src/test/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:testCompile (default-testCompile) @ simple_page ---
[INFO] No sources to compile
[INFO]
[INFO] <<< spring-boot-maven-plugin:2.0.0.RELEASE:run (default-cli) < test-compile @ simple_page <<<
[INFO]
[INFO]
[INFO] --- spring-boot-maven-plugin:2.0.0.RELEASE:run (default-cli) @ simple_page ---
 . ____ _ __ _ _
 /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/ ___)| |_)| | | | | || (_| | ) ) ) )
 ' |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot :: (v2.0.0.RELEASE)
2018-03-27 13:46:21.107 INFO 5559 --- [ main] com.gowhich.Application : Starting Application on durbanzhangdeMacBook-Pro with PID 5559 (/xxxxx/java/simple-page/target/classes started by durban in /xxxxx/java/simple-page)
2018-03-27 13:46:21.115 INFO 5559 --- [ main] com.gowhich.Application : No active profile set, falling back to default profiles: default
2018-03-27 13:46:21.208 INFO 5559 --- [ main] ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@3434bc22: startup date [Tue Mar 27 13:46:21 CST 2018]; root of context hierarchy
2018-03-27 13:46:23.629 INFO 5559 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port(s): 8080 (http)
2018-03-27 13:46:23.701 INFO 5559 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2018-03-27 13:46:23.701 INFO 5559 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/8.5.28
2018-03-27 13:46:23.732 INFO 5559 --- [ost-startStop-1] o.a.catalina.core.AprLifecycleListener : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/xxxxx/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
2018-03-27 13:46:23.887 INFO 5559 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2018-03-27 13:46:23.888 INFO 5559 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 2686 ms
2018-03-27 13:46:24.099 INFO 5559 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean : Servlet dispatcherServlet mapped to [/]
2018-03-27 13:46:24.108 INFO 5559 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'characterEncodingFilter' to: [/*]
2018-03-27 13:46:24.109 INFO 5559 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2018-03-27 13:46:24.110 INFO 5559 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2018-03-27 13:46:24.114 INFO 5559 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'requestContextFilter' to: [/*]
2018-03-27 13:46:24.755 INFO 5559 --- [ main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@3434bc22: startup date [Tue Mar 27 13:46:21 CST 2018]; root of context hierarchy
2018-03-27 13:46:24.909 INFO 5559 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2018-03-27 13:46:24.911 INFO 5559 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2018-03-27 13:46:24.984 INFO 5559 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-27 13:46:24.984 INFO 5559 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-27 13:46:25.090 INFO 5559 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-27 13:46:25.147 INFO 5559 --- [ main] o.s.b.a.w.s.WelcomePageHandlerMapping : Adding welcome page: class path resource [static/index.html]
2018-03-27 13:46:25.401 INFO 5559 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2018-03-27 13:46:25.488 INFO 5559 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2018-03-27 13:46:25.493 INFO 5559 --- [ main] com.gowhich.Application : Started Application in 5.141 seconds (JVM running for 11.502)

6、打开浏览器访问http://localhost:8080/index.html

得到类似如下输出的结果

7、如果想添加其他的静态页面可以在static目录下继续添加你需要的静态文件

实例代码可参考Github:https://github.com/durban89/spring_boot_simple_page/tree/master

Gradle 运行Spring Boot Application

Mon, 28 Jul 2025 17:48:43 +0800

1、gradle初始化

执行如下命令

gradle init

执行后会生成如下文件

drwxr-xr-x 8 durban staff 272 3 25 12:37 .
drwxr-xr-x 7 durban staff 238 3 25 12:36 ..
drwxr-xr-x 4 durban staff 136 3 25 12:37 .gradle
-rw-r--r-- 1 durban staff 201 3 25 12:37 build.gradle
drwxr-xr-x 3 durban staff 102 3 25 12:37 gradle
-rwxr-xr-x 1 durban staff 5296 3 25 12:37 gradlew
-rw-r--r-- 1 durban staff 2260 3 25 12:37 gradlew.bat
-rw-r--r-- 1 durban staff 351 3 25 12:37 settings.gradle

2、编辑build.gradle

在build.gradle文件下加入如下内容

plugins {
	id 'org.springframework.boot' version '2.0.0.RELEASE'
 id "io.spring.dependency-management" version "1.0.4.RELEASE"
	id 'java'
}
jar {
	baseName = 'myproject'
	version = '0.0.1-SNAPSHOT'
}
repositories {
	jcenter()
}
dependencies {
	compile("org.springframework.boot:spring-boot-starter-web")
	testCompile("org.springframework.boot:spring-boot-starter-test")
}

3、创建Spring Boot 实例代码

在跟目录下创建src/main/java结构的目录，并创建文件src/main/java/Example.java

添加如下代码

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
 @RequestMapping("/")
 String home() {
 return "Hello World!";
 }
 public static void main(String[] args) throws Exception {
 SpringApplication.run(Example.class, args);
 }
}

4、启动实例项目

执行如下命令

gradle bootRun

会得到如下内容

Starting a Gradle Daemon, 1 stopped Daemon could not be reused, use --status for details
> Task :bootRun
 . ____ _ __ _ _
 /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/ ___)| |_)| | | | | || (_| | ) ) ) )
 ' |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot :: (v2.0.0.RELEASE)
2018-03-25 12:58:25.611 INFO 62057 --- [ main] Example : Starting Example on durbanzhangdeMacBook-Pro with PID 62057 (/Users/durban/java/test/build/classes/java/main started by durban in /Users/durban/java/test)
2018-03-25 12:58:25.615 INFO 62057 --- [ main] Example : No active profile set, falling back to default profiles: default
2018-03-25 12:58:25.694 INFO 62057 --- [ main] ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@6279cee3: startup date [Sun Mar 25 12:58:25 CST 2018]; root of context hierarchy
2018-03-25 12:58:27.350 INFO 62057 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port(s): 8080 (http)
2018-03-25 12:58:27.400 INFO 62057 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2018-03-25 12:58:27.400 INFO 62057 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/8.5.28
2018-03-25 12:58:27.417 INFO 62057 --- [ost-startStop-1] o.a.catalina.core.AprLifecycleListener : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/durban/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
2018-03-25 12:58:27.561 INFO 62057 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2018-03-25 12:58:27.561 INFO 62057 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 1870 ms
2018-03-25 12:58:27.758 INFO 62057 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean : Servlet dispatcherServlet mapped to [/]
2018-03-25 12:58:27.764 INFO 62057 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'characterEncodingFilter' to: [/*]
2018-03-25 12:58:27.765 INFO 62057 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2018-03-25 12:58:27.765 INFO 62057 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2018-03-25 12:58:27.765 INFO 62057 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'requestContextFilter' to: [/*]
2018-03-25 12:58:28.259 INFO 62057 --- [ main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@6279cee3: startup date [Sun Mar 25 12:58:25 CST 2018]; root of context hierarchy
2018-03-25 12:58:28.377 INFO 62057 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/]}" onto java.lang.String Example.home()
2018-03-25 12:58:28.389 INFO 62057 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2018-03-25 12:58:28.390 INFO 62057 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2018-03-25 12:58:28.432 INFO 62057 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-25 12:58:28.432 INFO 62057 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-25 12:58:28.480 INFO 62057 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-25 12:58:28.701 INFO 62057 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2018-03-25 12:58:28.770 INFO 62057 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2018-03-25 12:58:28.776 INFO 62057 --- [ main] Example : Started Example in 3.815 seconds (JVM running for 4.321)
<=========----> 75% EXECUTING [19s]
> :bootRun

打开浏览器访问localhost:8080

会得到输出内容 “Hello World!”

5、创建可执行的jar文件

修改build.gradle,在jar中添加enabled=true,最后build.gradle结果如下

plugins {
	id 'org.springframework.boot' version '2.0.0.RELEASE'
 id "io.spring.dependency-management" version "1.0.4.RELEASE"
	id 'java'
}

jar {
	baseName = 'myproject'
	version = '0.0.1-SNAPSHOT'
 enabled = true
}

repositories {
	jcenter()
}

dependencies {
	compile("org.springframework.boot:spring-boot-starter-web")
	testCompile("org.springframework.boot:spring-boot-starter-test")
}

修改完后执行如下命令

spring bootRun

会在build目录下下libs目录下生成文件*.jar

通过命令运行jar文件

java -jar xxx.jar

会得到4步骤中的输出。

Maven 运行Spring Boot Application

Mon, 28 Jul 2025 17:48:38 +0800

1、创建pom.xml ，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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
</parent>
<!-- Additional lines to be added here... -->
</project>

执行命令

mvn depencency:tree

maven会自动安装默认的依赖文件

2、添加应用依赖

当开发一个具体类型的应用时需要添加具体的依赖，当我们开发一个WEB应用的时候，我们添加一个spring-boot-starter-web依赖，为了添加依赖我们在文件pom.xml文件的parent部分下面添加如下代码

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>

添加后代码如下

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
</parent>
<!-- Additional lines to be added here... -->
<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>
</project>

3、创建类文件

为了完成我们的应用，我们创建一个简单的Java文件，默认情况下，Maven从src/main/java编译源文件，因为我们创建一个src/main/java结构的目录，添加文件src/main/java/Example.java 代码内容如下

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
 @RequestMapping("/")
 String home() {
 return "Hello World!";
 }
 public static void main(String[] args) throws Exception {
 SpringApplication.run(Example.class, args);
 }
}

4、运行项目

mvn spring-boot:run

会得到如下输出

[INFO] Scanning for projects...
[INFO]
[INFO] -----------------------< com.example:myproject >------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] >>> spring-boot-maven-plugin:2.0.0.RELEASE:run (default-cli) > test-compile @ myproject >>>
[INFO]
[INFO] --- maven-resources-plugin:3.0.1:resources (default-resources) @ myproject ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /Users/durban/java/spring-test/src/main/resources
[INFO] skip non existing resourceDirectory /Users/durban/java/spring-test/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:compile (default-compile) @ myproject ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:3.0.1:testResources (default-testResources) @ myproject ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /Users/durban/java/spring-test/src/test/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:testCompile (default-testCompile) @ myproject ---
[INFO] No sources to compile
[INFO]
[INFO] <<< spring-boot-maven-plugin:2.0.0.RELEASE:run (default-cli) < test-compile @ myproject <<<
[INFO]
[INFO]
[INFO] --- spring-boot-maven-plugin:2.0.0.RELEASE:run (default-cli) @ myproject ---
 . ____ _ __ _ _
 /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/ ___)| |_)| | | | | || (_| | ) ) ) )
 ' |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot :: (v2.0.0.RELEASE)
2018-03-18 21:28:07.473 INFO 53370 --- [ main] Example : Starting Example on durbanzhangdeMacBook-Pro with PID 53370 (/Users/durban/java/spring-test/target/classes started by durban in /Users/durban/java/spring-test)
2018-03-18 21:28:07.478 INFO 53370 --- [ main] Example : No active profile set, falling back to default profiles: default
2018-03-18 21:28:07.593 INFO 53370 --- [ main] ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@66705b68: startup date [Sun Mar 18 21:28:07 CST 2018]; root of context hierarchy
2018-03-18 21:28:09.585 INFO 53370 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port(s): 8080 (http)
2018-03-18 21:28:09.679 INFO 53370 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2018-03-18 21:28:09.680 INFO 53370 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/8.5.28
2018-03-18 21:28:09.718 INFO 53370 --- [ost-startStop-1] o.a.catalina.core.AprLifecycleListener : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/durban/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
2018-03-18 21:28:09.970 INFO 53370 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2018-03-18 21:28:09.970 INFO 53370 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 2384 ms
2018-03-18 21:28:10.143 INFO 53370 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean : Servlet dispatcherServlet mapped to [/]
2018-03-18 21:28:10.149 INFO 53370 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'characterEncodingFilter' to: [/*]
2018-03-18 21:28:10.150 INFO 53370 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2018-03-18 21:28:10.150 INFO 53370 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2018-03-18 21:28:10.150 INFO 53370 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'requestContextFilter' to: [/*]
2018-03-18 21:28:10.597 INFO 53370 --- [ main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@66705b68: startup date [Sun Mar 18 21:28:07 CST 2018]; root of context hierarchy
2018-03-18 21:28:10.726 INFO 53370 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/]}" onto java.lang.String Example.home()
2018-03-18 21:28:10.734 INFO 53370 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2018-03-18 21:28:10.735 INFO 53370 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2018-03-18 21:28:10.785 INFO 53370 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-18 21:28:10.785 INFO 53370 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-18 21:28:10.836 INFO 53370 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-18 21:28:11.058 INFO 53370 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2018-03-18 21:28:11.133 INFO 53370 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2018-03-18 21:28:11.139 INFO 53370 --- [ main] Example : Started Example in 4.908 seconds (JVM running for 10.071)

访问localhost:8080，你将看到输出如下内容

Hello World!

4、创建一个可执行的jar文件

为了创建可执行的jar文件,我们添加spring-boot-maven-plugin到我们的pom.xml文件

<build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
</build>

添加后文件内容如下

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
</parent>
<!-- Additional lines to be added here... -->
<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>
<build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
</build>
</project>

然后执行如下命令

mvn package

执行完后查看target目录，可以看到myproject-0.0.1-SNAPSHOT.jar文件，

为了运行项目，执行如下命令

java -jar target/myproject-0.0.1-SNAPSHOT.jar

得到的结果跟第4步一样的输出

初步了解Spring Boot

Mon, 28 Jul 2025 17:48:35 +0800

1、安装Spring Boot CLI

可以通过下载Spring CLI安装包进行安装

具体的版本安装可以到这里下载

https://docs.spring.io/autorepo/docs/spring-boot/current/reference/html/getting-started-installing-spring-boot.html#getting-started-homebrew-cli-installation

本人使用OSX，演示下如何在OSX下安装,【brew的安装请自行百度】

执行如下命令

brew tap pivotal/tap

得到如下输出，表示执行成功

Cloning into '/usr/local/Homebrew/Library/Taps/pivotal/homebrew-tap'...
remote: Counting objects: 15, done.
remote: Compressing objects: 100% (14/14), done.
remote: Total 15 (delta 0), reused 6 (delta 0), pack-reused 0
Unpacking objects: 100% (15/15), done.
Tapped 10 formulae (50 files, 37.3KB)

在执行下面命令

brew install springboot

得到如下输出，表示执行成功

==> Installing springboot from pivotal/tap
==> Downloading https://repo.spring.io/release/org/springframework/boot/spring-boot-cli/2.0.0.RELEASE/spring-boot-cli-2.0.0.RELEASE-bin.tar.gz
Already downloaded: /Users/durban/Library/Caches/Homebrew/springboot-2.0.0.RELEASE.tar.gz
==> Caveats
Bash completion has been installed to:
 /usr/local/etc/bash_completion.d
zsh completions have been installed to:
 /usr/local/share/zsh/site-functions
==> Summary
/usr/local/Cellar/springboot/2.0.0.RELEASE: 7 files, 9.6MB, built in 1 second

下面我们来演示一个例子

创建文件hello.groovy

代码内容如下

@RestController
class WebApplication {
	@RequestMapping('/')
	String home() {
		"Hello World! Spring"
	}
}

保存后，执行下面命令

spring run hello.groovy

得到如下输出后，表示执行运行成功

$ spring run hello.groovy

 . ____ _ __ _ _
 /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/ ___)| |_)| | | | | || (_| | ) ) ) )
 ' |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot :: (v1.5.9.RELEASE)

2018-03-14 21:51:28.977 INFO 44846 --- [ runner-0] o.s.boot.SpringApplication : Starting application on durbanzhangdeMacBook-Pro with PID 44846 (started by durban in /Users/durban/java)
2018-03-14 21:51:28.993 INFO 44846 --- [ runner-0] o.s.boot.SpringApplication : No active profile set, falling back to default profiles: default
2018-03-14 21:51:29.352 INFO 44846 --- [ runner-0] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@f88b4c3: startup date [Wed Mar 14 21:51:29 CST 2018]; root of context hierarchy
2018-03-14 21:51:31.638 INFO 44846 --- [ runner-0] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
2018-03-14 21:51:31.656 INFO 44846 --- [ runner-0] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2018-03-14 21:51:31.658 INFO 44846 --- [ runner-0] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/8.5.23
2018-03-14 21:51:31.772 INFO 44846 --- [ost-startStop-1] org.apache.catalina.loader.WebappLoader : Unknown loader org.springframework.boot.cli.compiler.ExtendedGroovyClassLoader$DefaultScopeParentClassLoader@22d12a12 class org.springframework.boot.cli.compiler.ExtendedGroovyClassLoader$DefaultScopeParentClassLoader
2018-03-14 21:51:31.913 INFO 44846 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2018-03-14 21:51:31.914 INFO 44846 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 2567 ms
2018-03-14 21:51:32.126 INFO 44846 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean : Mapping servlet: 'dispatcherServlet' to [/]
2018-03-14 21:51:32.135 INFO 44846 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'characterEncodingFilter' to: [/*]
2018-03-14 21:51:32.136 INFO 44846 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2018-03-14 21:51:32.136 INFO 44846 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2018-03-14 21:51:32.136 INFO 44846 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean : Mapping filter: 'requestContextFilter' to: [/*]
2018-03-14 21:51:32.586 INFO 44846 --- [ runner-0] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@f88b4c3: startup date [Wed Mar 14 21:51:29 CST 2018]; root of context hierarchy
2018-03-14 21:51:32.719 INFO 44846 --- [ runner-0] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/]}" onto public java.lang.String WebApplication.home()
2018-03-14 21:51:32.722 INFO 44846 --- [ runner-0] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2018-03-14 21:51:32.723 INFO 44846 --- [ runner-0] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2018-03-14 21:51:32.791 INFO 44846 --- [ runner-0] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-14 21:51:32.791 INFO 44846 --- [ runner-0] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-14 21:51:32.865 INFO 44846 --- [ runner-0] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-03-14 21:51:33.565 INFO 44846 --- [ runner-0] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2018-03-14 21:51:33.689 INFO 44846 --- [ runner-0] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)

访问http://localhost:8080可以看到输出“Hello World! Spring”

Ctrl+c 可以终止运行

$ java -version
java version "1.8.0_121"
Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

Spring-Boot on Dapeng Zhang

vscode run spring boot - The newly created daemon process has a different context than expected

Spring - Spring Boot 2.4.0.M3发布

Spring boot基础学习记录之与Redis消息传递

与Redis消息传递(Messaging with Redis)

1、Build With Gradle

2、启动Redis服务器

3、创建Redis消息接收器

4、注册监听器并发送消息

5、构建可执行的JAR

Spring boot基础学习记录之完善通过Facebook注册一个应用

首先在社交平台注册一个应用 (Register your application)

编辑应用的配置添加配置属性 (Edit application.properties)

添加Spring Social依赖库 (Add Spring Social Dependencies)

配置Spring Social (Configure Spring Social)

创建视图

调用API

第一个疑惑

第二个疑惑

第三个疑问

第四个疑问

第五个疑问

Spring boot基础学习记录之使用Facebook注册一个应用

实践环境

Spring Boot基础学习记录之使用LDAP对用户进行身份验证

实践环境

创建一个简单的web controller

配置Spring Security

创建WebSecurityConfig.java

application.properties配置

添加src/main/resources/test-server.ldif

Spring Boot基础学习记录之Uploading Files(上传文件)部分代码解惑

实践环境

实践项目

Spring Boot基础学习记录之Uploading Files(上传文件)

实践环境

实践项目初始化

Maven配置

创建StorageService与存储层进行交互，如"文件系统"

创建上传文件的控制器

创建一个HTML模板

调整文件上传限制

Application配置

Spring Boot基础学习记录之使用JDBC访问关系数据

Spring Boot基础之构建一个REST风格的Web服务

Spring Boot基础之调度任务

Spring Boot基础之数据库连接

Spring Boot基础之简单的动态页面实现

Spring Boot基础之简单的路由配置

Spring Boot基础之自定义错误页面

Spring Boot基础之简单的模板配置使用

Spring Boot 基础之简单的静态页面实现

Gradle 运行Spring Boot Application

Maven 运行Spring Boot Application

初步了解Spring Boot