分类 java 下的文章

2024-08-29

在Spring Boot中，配置MySQL数据库连接池的大小通常涉及到两个参数：spring.datasource.hikari.maximum-pool-size 和 spring.datasource.hikari.minimum-idle。以下是如何在application.properties或application.yml配置文件中设置这些值的例子：

application.properties:




spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useSSL=false
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
# 设置连接池最大连接数
spring.datasource.hikari.maximum-pool-size=10
# 设置连接池最小空闲连接
spring.datasource.hikari.minimum-idle=5

application.yml:




spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_database?useSSL=false
    username: your_username
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5

在这个例子中，maximum-pool-size设置为10，表示连接池最多可以有10个并发连接；minimum-idle设置为5，表示连接池应该保持至少5个空闲连接。根据实际需求调整这些值。

- 阅读更多 -

springboot系列十一:Thymeleaf

System

2024-08-29

所有,java

Thymeleaf是一个用于Web和继承字符串的Java库，它提供了一种模板引擎，可以在HTML5的基础上生成XML、XHTML、HTML5等格式的文件。

在Spring Boot中，我们可以使用Thymeleaf作为模板引擎来创建动态网页。

以下是一个简单的例子，展示了如何在Spring Boot项目中使用Thymeleaf：

首先，在pom.xml中添加Thymeleaf依赖：




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

在src/main/resources/templates目录下创建一个名为greeting.html的Thymeleaf模板：




<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Greeting</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'"></h1>
</body>
</html>

在你的Controller中添加一个映射方法，返回模板视图：




import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
 
@Controller
public class GreetingController {
 
    @GetMapping("/greeting")
    public String greeting(@RequestParam(name="name", required=false, defaultValue="World") String name, Model model) {
        model.addAttribute("name", name);
        return "greeting";
    }
}

当你访问/greeting这个URL时，Spring Boot应用将会使用Thymeleaf渲染greeting.html模板，并显示出来。

这只是一个非常基础的例子，Thymeleaf还有更多强大的功能，例如条件表达式、迭代器变量等，可以用于创建更复杂的动态网页。

- 阅读更多 -

Spring Boot 3.x 使用 Druid

System

2024-08-29

所有,java

在Spring Boot 3.x中使用Druid数据库连接池，首先需要添加Druid的依赖到项目中。以下是Maven的依赖配置示例：




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

然后，在application.properties或application.yml配置文件中配置Druid连接池的属性：




# 数据源类型设置为Druid
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
 
# Druid数据源专有配置
spring.datasource.druid.url=jdbc:mysql://localhost:3306/yourdb
spring.datasource.druid.username=root
spring.datasource.druid.password=yourpassword
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
 
# 初始化大小，最小，最大
spring.datasource.druid.initial-size=5
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-active=20
 
# 配置获取连接等待超时的时间
spring.datasource.druid.max-wait=60000
 
# 配置间隔多久进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.druid.time-between-eviction-runs-millis=60000
 
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.druid.min-evictable-idle-time-millis=300000
 
# 用来检测连接是否有效的SQL
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
 
# 配置间隔多久进行一次检测不活动连接，单位是毫秒
spring.datasource.druid.phase-of-pool-check=60000

以上配置了基本的Druid数据库连接池属性，包括数据库URL、用户名、密码、初始连接数、最小空闲连接、最大活跃连接数等。

在Spring Boot 3.x中，Druid的自动配置已经由druid-spring-boot-starter提供，所以通常不需要额外的配置。只要添加了上述依赖，大多数配置会自动应用。如果需要自定义Druid的监控页面或者配置更多高级特性，可以添加自己的配置类来覆盖默认配置。

System

2024-08-29

所有,java




import org.springframework.cloud.config.server.EnableConfigServer;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableConfigServer
public class ConfigServerApplication {
 
    // 这里可以添加更多的配置，比如数据库连接信息等
 
}

这段代码演示了如何在Spring Cloud Config中启用配置服务器。通过@EnableConfigServer注解，Spring Boot应用会自动配置为Config Server，从而可以提供高可用的配置服务。在实际部署时，可以通过负载均衡器将请求分发到多个Config Server实例以实现高可用。

- 阅读更多 -

Tomcat解压打包文件和并部署

System

2024-08-29

所有,java

在Tomcat中解压并部署一个WAR包文件，通常涉及以下步骤：

将WAR文件复制到Tomcat的webapps目录。
启动Tomcat服务器，它将自动检测新的WAR文件并进行解压。
部署完成后，你可以通过访问http://<hostname>:<port>/<YourAppName>来访问你的应用程序。

以下是一个简单的Shell脚本，用于自动执行这些步骤：




#!/bin/bash
 
# 设置Tomcat的安装目录和WAR文件路径
CATALINA_HOME="/path/to/your/tomcat"
WAR_FILE_PATH="/path/to/your/app.war"
 
# 复制WAR文件到Tomcat的webapps目录
cp $WAR_FILE_PATH $CATALINA_HOME/webapps/
 
# 启动Tomcat
sh $CATALINA_HOME/bin/startup.sh
 
# 打印出Tomcat运行日志
tail -f $CATALINA_HOME/logs/catalina.out

确保替换CATALINA_HOME和WAR_FILE_PATH为你的Tomcat安装路径和WAR文件的实际路径。

这个脚本会将WAR文件复制到Tomcat的webapps目录，并启动Tomcat。tail -f命令用于在控制台实时打印Tomcat的运行日志，以便监视部署过程。

请注意，这个脚本假定Tomcat已经正确安装，且startup.sh具有执行权限。如果你的环境有特殊要求，可能需要修改脚本以适应。

System

2024-08-29

所有,java

Feign是一个声明式的Web服务客户端，用来简化HTTP远程调用。在Spring Cloud Alibaba微服务实战中，使用Feign可能遇到的一些问题及其解决方法如下：

超时问题：Feign默认使用JDK的URLConnection作为HTTP客户端，它的超时设置不够灵活。可以通过配置Feign的超时时间来解决：




feign:
  client:
    config:
      default:
        connectTimeout: 10000 # 连接超时时间（毫秒）
        readTimeout: 10000    # 读取超时时间（毫秒）

日志级别问题：Feign的日志级别可以通过配置来调整，方便调试：




logging:
  level:
    com.example.service.YourFeignClient: DEBUG

异步调用：Feign本身不直接支持异步调用，但可以配合Spring WebFlux使用。
响应数据转换问题：Feign默认使用Jackson来解析JSON数据。如果需要使用其他数据格式或解析器，可以通过配置Feign的Encoder和Decoder来实现。
异常处理：Feign可以集成Hystrix，实现断路器模式，从而提供更优雅的错误处理机制。
自定义HTTP请求头：Feign可以通过RequestInterceptor来添加或修改HTTP请求头。




@Configuration
public class FeignConfig {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return requestTemplate -> requestTemplate.header("Custom-Header", "value");
    }
}

使用Feign时，要确保Feign的依赖和版本与Spring Cloud Alibaba的版本兼容。

这些是使用Feign时可能遇到的一些常见问题及其解决方法，具体情况可能需要根据实际需求和环境调整。

- 阅读更多 -

Spring Boot RESTful API 示例

System

2024-08-29

所有,java

以下是一个简单的Spring Boot RESTful API示例，它定义了一个用户实体和一个简单的控制器，用于获取用户列表。




// User.java
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
 
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private String email;
 
    // Getters and Setters
    // ...
}
 
// UserController.java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.ArrayList;
 
@RestController
@RequestMapping("/api/users")
public class UserController {
 
    // 假设这是从数据库获取用户列表的服务
    // 实际应用中，你会使用对应的服务层代码
    private List<User> users = new ArrayList<>();
 
    public UserController() {
        users.add(new User(1L, "John Doe", "john.doe@example.com"));
        users.add(new User(2L, "Jane Doe", "jane.doe@example.com"));
    }
 
    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }
}
 
// Application.java
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);
    }
}

这个示例展示了如何创建一个简单的RESTful API，它提供了一个获取用户列表的端点。在实际的应用中，你需要使用Spring Data JPA或其他ORM框架来与数据库交互，并且要确保你的应用具有正确的安全性措施，比如使用Spring Security。

- 阅读更多 -

SpringBoot-04-文件上传本地以及对象存储OSS

System

2024-08-29

所有,java




import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import com.aliyun.oss.OSS;
import com.aliyun.oss.common.utils.BinaryUtil;
import com.aliyun.oss.common.utils.StringUtils;
import com.aliyun.oss.model.MatchMode;
import com.aliyun.oss.model.PolicyConditions;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
 
@RestController
public class FileUploadController {
 
    @PostMapping("/upload")
    public Map<String, String> uploadFile(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            throw new RuntimeException("文件不能为空");
        }
 
        // 文件名
        String fileName = file.getOriginalFilename();
 
        // 上传到本地文件系统
        String localFilePath = "/path/to/local/directory/" + fileName;
        file.transferTo(new java.io.File(localFilePath));
 
        // 上传到OSS
        String endpoint = "您的EndPoint";
        String accessKeyId = "您的AccessKeyId";
        String accessKeySecret = "您的AccessKeySecret";
        String bucketName = "您的Bucket名称";
        String key = "文件路径和名称";
 
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        try {
            ossClient.putObject(bucketName, key, file.getInputStream());
        } catch (IOException e) {
            throw new RuntimeException("上传OSS失败", e);
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
 
        Map<String, String> result = new LinkedHashMap<>();
        result.put("localFilePath", localFilePath);
        result.put("OSSFilePath", "https://" + bucketName + "." + endpoint + "/" + key);
        return result;
    }
 
    @GetMapping("/policy")
    public Map<String, String> getPolicy() {
        String endpoint = "您的EndPoint";
        String accessKeyId = "您的AccessKeyId";
        String accessKeySecret = "您的AccessKeySecret";
        String bucketName = "您的Bucket名称";
 
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        try {
            long expireTime = 30;
            long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
            Date expiration = new Date(expireEndTime);
            PolicyConditions policyConds = new P

- 阅读更多 -

Java过滤器doFilter里chain.doFilter()函数的理解

System

2024-08-29

所有,java

chain.doFilter()方法在Java的Servlet过滤器（Filter）中的doFilter方法体内调用，表示执行链中的下一个过滤器或者目标资源。如果调用这个方法之前的过滤器已经对请求做了一些处理，那么调用chain.doFilter()会触发执行下一个过滤器或者Servlet的service方法（如果没有更多的过滤器了）。

如果你想在过滤器链中控制请求的处理，你可能会在调用chain.doFilter()之前或之后添加一些逻辑。这样可以在处理请求之前或之后进行某些操作，比如参数的修改、权限的验证、日志记录等。

下面是一个简单的例子，展示了如何在过滤器中使用chain.doFilter()方法：




public class ExampleFilter implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 过滤器初始化
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 在请求被处理之前可以进行一些操作
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 例如，可以记录请求的信息
        System.out.println("Before processing the request: " + httpServletRequest.getRequestURI());
 
        // 传递控制到下一个过滤器或者目标资源
        chain.doFilter(request, response);
 
        // 在请求被处理之后可以进行一些操作
        // 例如，可以记录请求的响应信息
        System.out.println("After processing the request: " + httpServletRequest.getRequestURI());
    }
 
    @Override
    public void destroy() {
        // 过滤器销毁
    }
}

在这个例子中，doFilter方法体内先打印了请求的URI，然后调用了chain.doFilter()来处理请求，最后再次打印了请求的URI。这样就可以在请求处理前后进行一些自定义的逻辑。

- 阅读更多 -

使用Java实现转发请求的方式

System

2024-08-29

所有,java

在Java中，可以使用HttpURLConnection或第三方库如Apache HttpClient来实现请求转发。以下是使用HttpURLConnection的一个简单示例：




import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
 
public class RequestForwarder {
 
    public static void forwardRequest(String forwardUrl, String targetUrl) throws Exception {
        // 打开连接
        URL url = new URL(forwardUrl);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
 
        // 设置请求方法
        connection.setRequestMethod("GET");
 
        // 可以添加额外的请求头
        // connection.setRequestProperty("Header-Name", "Header-Value");
 
        // 发送请求
        connection.connect();
 
        // 检查响应状态
        int status = connection.getResponseCode();
        if (status == HttpURLConnection.HTTP_OK) {
            // 读取响应内容
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            StringBuilder content = new StringBuilder();
            while ((inputLine = in.readLine()) != null) {
                content.append(inputLine);
            }
            in.close();
 
            // 打印内容
            System.out.println(content.toString());
 
            // 可以继续将内容转发到目标URL
            // forwardContentToTarget(targetUrl, content.toString());
        } else {
            System.out.println("GET request not worked");
        }
 
        // 关闭连接
        connection.disconnect();
    }
 
    // 示例方法，实际使用时需要根据需求实现
    // private static void forwardContentToTarget(String targetUrl, String content) {
    //     // 实现内容转发到目标URL的逻辑
    // }
 
    public static void main(String[] args) {
        // 转发请求的URL
        String forwardUrl = "http://example.com/api/data";
        // 目标URL
        String targetUrl = "http://target-example.com/api/data";
 
        try {
            forwardRequest(forwardUrl, targetUrl);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，forwardRequest方法接受两个参数：forwardUrl是要转发请求的原始URL，targetUrl是转发请求后，响应内容要转发到的目标URL。这个例子使用了HttpURLConnection来发送请求，并打印了响应内容。如果需要将内容转发到另一个服务器，可以实现forwardContentToTarget方法，并在适当的地方调用它。

请注意，这只是一个基本的转发示例，实际应用中可能需要处理更多的情况，例如HTTP方法（POST, GET, PUT, DELETE等）、请求头、错误处理、超时设置等。

- 阅读更多 -