markdown-it demo

clear permalink

TODO [Detecting If a Spring Transaction Is Active](https://www.baeldung.com/spring-transaction-active)

TODO [Spring Boot 單元測試(Unit Test)](https://ithelp.ithome.com.tw/articles/10196471)

### [Common Application Properties](https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html)

### [Spring Profiles](https://www.baeldung.com/spring-profiles)
application.yml
```yml
spring:
  profiles:
    active:
      - ${SPRING_PROFILE:dev}
```
application-dev.yml
```yml
logging:
  level:
    root: ${LOG_LEVEL:DEBUG}
```
application-prod.yml
```yml
logging:
  level:
    root: ${LOG_LEVEL:INFO}
```
AppConfig.java
```java
@Component
@Profile("dev")
public class DevDatasourceConfig {
}
```
```java
@Component
@Profile("prod")
public class ProdDatasourceConfig {
}
```

### [Spring 5 WebClient](https://www.baeldung.com/spring-5-webclient)
[Spring WebClient (with Examples)](https://howtodoinjava.com/spring-webflux/webclient-get-post-example/)

pom.xml
```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
```
```java
WebClient webClient1 = WebClient.create();
WebClient webClient2 = WebClient.create("https://client-domain.com");

WebClient webClient3 = WebClient.builder()
  .baseUrl("http://localhost:8080")
  .defaultCookie("cookieKey", "cookieValue")
  .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) 
  .defaultUriVariables(Collections.singletonMap("url", "http://localhost:8080"))
  .build();
```
```java
Employee createdEmployee = webClient3.post()
		.uri("/employees")
		.header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
		.body(Mono.just(empl), Employee.class)
		.retrieve()
		.bodyToMono(Employee.class);
```
Creating a WebClient Instance with Timeouts
```java
HttpClient httpClient = HttpClient.create()
  .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
  .responseTimeout(Duration.ofMillis(5000))
  .doOnConnected(conn -> 
    conn.addHandlerLast(new ReadTimeoutHandler(5000, TimeUnit.MILLISECONDS))
      .addHandlerLast(new WriteTimeoutHandler(5000, TimeUnit.MILLISECONDS)));

WebClient client = WebClient.builder()
  .clientConnector(new ReactorClientHttpConnector(httpClient))
  .build();
```

### [WebClientFluxExample](https://chat.openai.com/chat)
```java
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class WebClientFluxExample {
    public static void main(String[] args) {
        // 創建 WebClient 對象
        WebClient webClient = WebClient.builder().baseUrl("http://localhost:8080").build();

// 要 POST 的數據，使用 Flux 包裝
        Flux<String> body = Flux.just("data1", "data2", "data3");

// 設置 POST 請求的 headers 和 body
        Mono<String> response = webClient.post()
                .uri("/endpoint")
                .contentType(MediaType.APPLICATION_STREAM_JSON)
                .body(BodyInserters.fromPublisher(body, String.class))
                .retrieve()
                .bodyToMono(String.class);

// 發送請求並處理結果
        response.subscribe(
                result -> System.out.println("Response: " + result),
                error -> System.err.println("Error: " + error.getMessage()),
                () -> System.out.println("Request completed.")
        );
    }
}
```
這個例子中，我們首先創建了一個 WebClient 對象，並指定要訪問的 URL 為 http://localhost:8080。

接著，我們使用 Flux 包裝了要 POST 的數據，並設置 POST 請求的 headers 和 body。

最後，我們使用 retrieve() 方法發送請求，並使用 bodyToMono() 方法將結果轉換為 Mono。在訂閱 Mono 之後，我們就可以處理請求的結果了。

值得注意的是，這個例子中使用的是 APPLICATION_STREAM_JSON 媒體類型，這是一個用於支持流數據的媒體類型。如果你要 POST 的是普通的 JSON 數據，可以使用 APPLICATION_JSON 媒體類型。

### [WebClientFlux bodyToFlux](https://chat.openai.com/chat)
```java
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;

// 創建一個 WebFlux 客戶端
WebClient webClient = WebClient.create();

// 發送 POST 請求，並使用 Flux 回傳結果
Flux<String> resultFlux = webClient.post()
        .uri("https://example.com/api/some-endpoint")
        .contentType(MediaType.APPLICATION_JSON)
        .bodyValue(someJsonRequestBody)
        .retrieve()
        .bodyToFlux(String.class);
```
以上範例中，我們使用 WebClient.create() 創建了一個 WebClient 實例，然後使用 .post() 方法設置 HTTP 請求方法為 POST，.uri() 方法設置請求的 URI，.contentType() 方法設置請求的內容類型為 JSON，.bodyValue() 方法設置請求的內容，最後使用 .retrieve() 方法發送請求並獲取響應結果。

在 .bodyToFlux() 方法中，我們指定了 String.class，表示我們期望響應的主體是一個字串，然後方法返回一個 Flux<String> 物件，用於異步處理請求響應。

當我們訂閱 resultFlux 物件時，WebClient 將會發送 HTTP 請求，並在響應到達時將響應的主體以 String 的形式傳遞給我們。

### [JavaMailSender](https://morosedog.gitlab.io/springboot-20190415-springboot27/)
基礎文本郵件
```java
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("jj.huang@hotmail.com");
        message.setTo("jj.huang@*****.com.tw");
        message.setSubject("主旨：Hello J.J.Huang");
        message.setText("內容：這是一封測試信件，恭喜您成功發送了唷");
        mailSender.send(message);
```
郵件帶有附件
```java
        MimeMessage mimeMessage = mailSender.createMimeMessage();

MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
        helper.setFrom("jj.huang@hotmail.com");
        helper.setTo("jj.huang@*****.com.tw");
        helper.setSubject("主旨：Hello J.J.Huang 附上附件");
        helper.setText("內容：請檢閱附件內容");

FileSystemResource file = new FileSystemResource(new File("hotmail.jpg"));
        helper.addAttachment("附件-1.jpg", file);
        helper.addAttachment("附件-2.jpg", file);

mailSender.send(mimeMessage);
```
郵件內文帶 HTML
```java
        MimeMessage mimeMessage = mailSender.createMimeMessage();

MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
        helper.setFrom("jj.huang@hotmail.com");
        helper.setTo("jj.huang@*****.com.tw");
        helper.setSubject("主旨：Hello J.J.Huang 嵌入靜態資源");
        helper.setText("<html><body><img src=\"cid:hotmail\" ></body></html>", true);

FileSystemResource file = new FileSystemResource(new File("hotmail.jpg"));
        helper.addInline("hotmail", file);

mailSender.send(mimeMessage);
```
### [Send Email with Thymeleaf template in Spring Boot](https://codingnconcepts.com/spring-boot/send-email-with-thymeleaf-template/)
```java
        MimeMessage message = emailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED, StandardCharsets.UTF_8.name());
        Context context = new Context();
        context.setVariables(email.getProperties());
        helper.setFrom(email.getFrom());
        helper.setTo(email.getTo());
        helper.setSubject(email.getSubject());
        String html = templateEngine.process(email.getTemplate(), context);
        helper.setText(html, true);

log.info("Sending email: {} with html body: {}", email, html);
        emailSender.send(message);
```

### 拋出 HTTP 狀態碼為 404 的異常

```java
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@RestController
public class MyController {

@GetMapping("/api/user/{id}")
    public User getUser(@PathVariable Long id) {
        User user = // 從資料庫或其他地方取得使用者資料

if (user == null) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "User not found with id: " + id);
        }

return user;
    }
}
```
### SpringBootServletInitializer
SpringBootServletInitializer 是 Spring Boot 中的一個抽象類，用於支援將 Spring Boot 應用部署到傳統的 Servlet 容器（如 Tomcat、Jetty 等）中，以 WAR 檔形式運行。它是 Spring Boot 的 Web Application 初始化器，提供了用於配置 Servlet 環境的相關功能。

當你的 Spring Boot 應用需要以 WAR 檔形式部署到 Servlet 容器中時，你需要創建一個繼承自 SpringBootServletInitializer 的子類，並重寫其中的 configure 方法。在這個方法中，你需要指定 Spring Boot 應用的主類（包含 main 方法的那個類），並將其設置為 Spring Boot 應用的入口。

這樣做的目的是為了讓 Servlet 容器能夠正確初始化 Spring Boot 應用的上下文，並將其設置為 Servlet 環境中的一個 Servlet。

總結來說，SpringBootServletInitializer 的主要用途是支援將 Spring Boot 應用部署到傳統的 Servlet 容器中，以 WAR 檔形式運行。如果你的 Spring Boot 應用是以 JAR 檔形式運行，並且不需要部署到 Servlet 容器中，則通常不需要使用 SpringBootServletInitializer。

### 指定 Bean
```java
@Configuration
public class YourConfiguration {

@Bean
    public Map<String, Object> beanA() {
        // 實現 A 方法的邏輯
        Map<String, Object> result = new HashMap<>();
        // ...
        return result;
    }

@Bean
    public Map<String, Object> beanB() {
        // 實現 B 方法的邏輯
        Map<String, Object> result = new HashMap<>();
        // ...
        return result;
    }
}
```
```java
@Service
public class YourService {
    @Autowired
    private Map<String, Object> beanA;
    // 依據變數名稱指定
}
```
```java
@Service
public class YourService {
    @Resource(name = "beanA")
    private Map<String, Object> beanA;
    // 依據字串來指定
}
```

---
### [spring initializr](https://start.spring.io/)

### Maven 建置檔
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.9</version>
		<relativePath/> 
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>11</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

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

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

</project>
```
### Gradle 建置檔
```gradle
plugins {
	id 'java'
	id 'org.springframework.boot' version '2.7.9'
	id 'io.spring.dependency-management' version '1.1.4'
}

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

java {
	sourceCompatibility = '11'
}

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
	useJUnitPlatform()
}

```

### ResourceLoader

在 Spring Boot 中，你可以使用 `ResourceLoader` 來直接讀取位於 `resources/static` 目錄下的靜態資源。以下是一個示例：

```java
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Service;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

@Service
public class StaticResourceService {

private final ResourceLoader resourceLoader;

public StaticResourceService(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

public String readStaticResource(String fileName) throws IOException {
        // 加載靜態資源
        Resource resource = resourceLoader.getResource("classpath:static/" + fileName);

// 使用 BufferedReader 讀取資源內容
        StringBuilder content = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(resource.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
        }

return content.toString();
    }
}
```

這個示例創建了一個 `StaticResourceService` 服務，它通過 `ResourceLoader` 加載 `resources/static` 目錄下的靜態資源。你可以調用 `readStaticResource` 方法並傳入靜態資源的文件名來讀取資源的內容。

請注意，`ResourceLoader` 將通過 `classpath:` 前綴來尋找資源。因此，靜態資源的路徑應該以 `static/` 開頭。

### 下載檔案的 API
要實作一個下載檔案的 API，可以使用Spring Boot框架中的RestController類和ResponseEntity類。以下是一個簡單的範例：

```java
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

@RestController
public class FileDownloadController {

@GetMapping("/download/{fileName}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String fileName) {
        Path filePath = Paths.get("<path_to_your_file_directory>" + fileName);
        Resource resource = null;
        
        try {
            resource = new org.springframework.core.io.UrlResource(filePath.toUri());
        } catch (IOException e) {
            e.printStackTrace();
        }

HttpHeaders headers = new HttpHeaders();
        // 下載的檔名
        headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + fileName);
        
        return ResponseEntity.ok()
                .headers(headers)
                .contentLength(resource.getFile().length())
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .body(resource);
    }
}
```

在這個範例中，我們首先使用@RestController註釋來宣告一個RestController類。接著，我們定義了一個名為downloadFile的方法，該方法使用@GetMapping註釋來映射到/download/{fileName}的路徑。該方法會根據fileName參數來讀取檔案，並將其轉換為Resource物件。最後，我們設定HTTP標頭，將檔案作為附件下載，並返回ResponseEntity物件。

請務必將<path_to_your_file_directory>替換為您實際儲存檔案的路徑。另外，也要注意在實際應用中確保適當的錯誤處理和檔案有效性驗證。

### Content Type
要在Spring Boot中使用FileSystemResource回應給使用者並給予對應的media type，我們可以使用ResponseEntity物件來實現。以下是一個範例：

```java
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

@RestController
public class FileController {

@GetMapping("/downloadFile")
    public ResponseEntity<FileSystemResource> downloadFile() throws IOException {
        String filePath = "/path/to/file.ext";
        File file = new File(filePath);
        FileSystemResource resource = new FileSystemResource(file);

HttpHeaders headers = new HttpHeaders();
        headers.add(HttpHeaders.CONTENT_TYPE, Files.probeContentType(file.toPath()));

return ResponseEntity.ok()
                .headers(headers)
                .body(resource);
    }
}
```

在上述範例中，我們首先建立一個RestController類別FileController，並在其中定義了一個名為downloadFile的GET端點。在這個方法中，我們建立了一個FileSystemResource對象並設定了檔案的路徑。接著，我們設定了HttpHeaders對象中的Content-Type標頭，根據檔案的MediaType來設定，然後我們使用ResponseEntity物件來回傳FileSystemResource對象並設定對應的HttpStatus為OK。

透過以上的方式，我們就可以利用FileSystemResource在Spring Boot中回應給使用者並給予對應的media type。

### User-Agent

在Spring Boot中，可以使用User-Agent來判斷使用者是透過電腦或手機瀏覽網頁。User-Agent是一個HTTP的header，它包含了使用者的瀏覽器和作業系統等資訊。

以下是一個示例程式碼，可以透過User-Agent判斷使用者是透過電腦或手機訪問網頁：

```java
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.view.RedirectView;
import javax.servlet.http.HttpServletRequest;

@RestController
public class UserController {

@GetMapping("/check-device")
    public String checkDevice(HttpServletRequest request) {

String userAgent = request.getHeader("User-Agent");

if (userAgent != null && userAgent.toLowerCase().contains("mobile")) {
            return "Handheld Device";
        } else {
            return "Computer";
        }
    }

@RequestMapping("/check")
    public RedirectView checkDeviceType(@RequestHeader("User-Agent") String userAgent) {
        if (StringUtils.containsIgnoreCase(userAgent, "mobile")) {
            return new RedirectView("https://www.google.com");
        }
        return new RedirectView("https://www.yahoo.com");
    }

}
```

在這個範例中，我們在UserController中定義了一個checkDevice的API端點，透過HttpServletRequest來取得User-Agent，在判斷User-Agent中是否含有"mobile"字串來判斷使用者是手機還是電腦。根據判斷結果，返回對應的結果字串。

html source debug