分类 java 下的文章

springboot3使用自定义注解＋Jackson优雅实现接口数据脱敏

2024-09-04

在Spring Boot 3中，你可以通过自定义注解和Jackson的@JsonSerializer来实现数据脱敏。以下是一个简单的例子：

自定义注解@DataMasking:




@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = DataMaskingSerializer.class)
public @interface DataMasking {
}

自定义数据脱敏的Serializer:




public class DataMaskingSerializer extends StdScalarSerializer<Object> implements ContextualSerializer {
 
    protected DataMaskingSerializer() {
        super(Object.class);
    }
 
    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        // 实现数据脱敏逻辑，例如用星号*替换部分字符
        String maskedValue = maskingLogic(value.toString());
        gen.writeString(maskedValue);
    }
 
    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
        return new DataMaskingSerializer();
    }
 
    private String maskingLogic(String value) {
        // 实现脱敏逻辑
        return "***"; // 举例，使用星号脱敏
    }
}

在实体类中使用@DataMasking注解:




public class User {
 
    private String id;
 
    @DataMasking
    private String username;
 
    // getters and setters
}

在application.properties或application.yml中配置Jackson:




spring.jackson.serialization.indent-output=true

使用上述配置，当你返回带有@DataMasking注解的字段的对象时，Jackson会自动使用DataMaskingSerializer进行数据脱敏处理。

ELK企业应用场景之Tomcat日志采集-logstash+es+kibana

2024-09-04

在实际应用中，我们通常需要将Tomcat的日志信息采集并存储至Elasticsearch中，然后通过Kibana进行可视化。以下是一个基于Logstash、Elasticsearch和Kibana的配置示例。

安装Logstash并确保其正常运行。
创建Logstash配置文件，例如tomcat-logs.conf，内容如下：




input {
  file {
    path => "/path/to/tomcat/logs/catalina.out"
    start_position => "beginning"
    sincedb_path => "/dev/null"
  }
}
 
filter {
  grok {
    match => { "message" => "%{DATA:timestamp}\s*%{DATA:loglevel}\s*%{DATA:class}\s*%{GREEDYDATA:message}" }
  }
 
  date {
    match => [ "timestamp" , "dd/MMM/yyyy:HH:mm:ss Z" ]
  }
}
 
output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "tomcat-logs-%{+YYYY.MM.dd}"
  }
}

根据实际情况调整path和日志格式的grok表达式。
启动Logstash并指定配置文件：




bin/logstash -f tomcat-logs.conf

确保Elasticsearch正常运行。
安装并启动Kibana，然后通过Web界面配置相应的index pattern以可视化Tomcat日志。

请注意，这只是一个基础示例，具体实施时可能需要根据实际日志格式和需求进行相应的调整。

Spring 事务机制

2024-09-04

Spring 提供了一种声明式事务管理的方式，它主要通过 AOP 代理来实现。你可以使用 @Transactional 注解来标记方法，以便于 Spring 在运行时应用事务边界。

以下是一个使用 @Transactional 注解的简单例子：




import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class MyService {
 
    @Transactional
    public void someTransactionalMethod() {
        // 方法的实现代码
        // 这里的代码将在一个事务的上下文中执行
    }
}

在这个例子中，someTransactionalMethod 方法被标记为事务性的。当这个方法被调用时，Spring 会开始一个事务，并确保这个方法内的所有操作要么全部成功，要么全部失败（根据事务的隔离级别和传播行为）。

事务的配置通常在 Spring 的配置文件中完成，例如使用 <tx:annotation-driven /> 来启用注解事务管理：




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
 
    <tx:annotation-driven transaction-manager="transactionManager" />
 
    <!-- 其他 Bean 的定义 -->
 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
 
</beans>

在这个配置中，<tx:annotation-driven /> 告诉 Spring 去自动发现标记为 @Transactional 的方法，并且使用 transactionManager 作为事务管理器。

请注意，实际的事务管理配置可能会更加复杂，包括数据库连接池、事务的隔离级别、超时设置、只读事务的指定等。

2024-09-04




import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class EmailService {
 
    private final JavaMailSender mailSender;
 
    @Autowired
    public EmailService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }
 
    public void sendSimpleMail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
 
        mailSender.send(message);
    }
}

这段代码定义了一个EmailService类，它使用JavaMailSender来发送简单邮件。在这个例子中，我们注入了JavaMailSender作为依赖，并提供了一个sendSimpleMail方法来发送邮件。这个类可以在Spring Boot应用中被注册为服务组件，并可以用来发送确认邮件、通知邮件等。

SpringCloud Nacos的配置与使用

2024-09-04

Spring Cloud Nacos Config 是一个用于微服务系统的配置中心组件，它能够让你更加方便地管理微服务配置信息。

以下是一个使用 Spring Cloud Nacos Config 的简单示例：

在 pom.xml 中添加依赖：




<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

在 bootstrap.properties 或 bootstrap.yml 中配置 Nacos server 的信息：




spring.cloud.nacos.config.server-addr=127.0.0.1:8848

在 application.properties 或 application.yml 中添加配置文件信息：




spring.application.name=example
spring.cloud.nacos.config.file-extension=yaml

在代码中注入配置：




import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class ConfigController {
 
    @Value("${useLocalCache:false}")
    private boolean useLocalCache;
 
    @GetMapping("/config")
    public boolean getConfig() {
        return useLocalCache;
    }
}

启动应用程序并访问 /config 端点，你将看到配置信息被正确读取并返回。

以上是一个基本的使用示例，实际使用时可能需要根据具体的配置管理策略和安全要求进行相应的配置。

Nginx+Tomcat负载均衡、动静分离原理

2024-09-04

在Nginx与Tomcat结合的场景下，Nginx通常作为反向代理服务器，负责分发请求到后端的Tomcat服务器，实现负载均衡。同时，Nginx可以处理静态文件请求，减少Tomcat的负载压力，实现动静分离。

以下是一个简单的Nginx配置示例，实现了负载均衡和动静分离：




# 定义Tomcat服务器组
upstream tomcat_server {
    server tomcat1.example.com:8080;
    server tomcat2.example.com:8080;
}
 
server {
    listen 80;
    server_name www.example.com;
 
    # 静态文件处理
    location ~* \.(jpg|jpeg|png|css|js|ico|html)$ {
        root /path/to/static/files;
        expires 30d;
    }
 
    # 处理动态请求，代理到Tomcat服务器组
    location / {
        proxy_pass http://tomcat_server;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

在这个配置中：

upstream 指令定义了一个名为 tomcat_server 的服务器组，包含了两个Tomcat服务器实例。
在 server 块中，listen 指定了监听端口为80，server_name 指定了服务器名。
对于静态文件，使用 location 指令匹配特定的文件扩展名，并指定了静态文件的根目录，同时设置了缓存时间。
对于动态请求，一样使用 location 指令匹配 / ，通过 proxy_pass 指令代理到名为 tomcat_server 的服务器组，并设置了必要的头信息，如 Host 和 X-Real-IP 等。

这样配置后，Nginx会接收到所有请求，静态文件由Nginx直接响应，而动态请求被代理到Tomcat服务器，并通过 tomcat_server 服务器组自动实现负载均衡。

写了一个minio-spring-boot-starter给大家使用

2024-09-04

在开发一个minio-spring-boot-starter时，可以遵循以下步骤：

创建一个新的Maven项目。
添加必要的依赖，如Spring Boot和MinIO客户端库。
创建配置类和自动配置类。
提供配置属性的绑定类。
创建服务类，封装MinIO客户端的操作。
创建自定义注解，用于标注需要自动配置的Bean。
编写自动配置生成Bean的逻辑。
编写自定义注解，用于标注需要自动配置的Bean。
编写自动配置生成Bean的逻辑。
创建示例代码，展示如何使用starter。
编写单元测试，确保功能正常。
发布到公共仓库或私有仓库供他人使用。

以下是一个简化的示例代码：




// MinioConfiguration.java
@Configuration
public class MinioConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public MinioClient minioClient(MinioProperties properties) throws InvalidPortException, InvalidEndpointException, IOException {
        return MinioClient.builder()
                .endpoint(properties.getEndpoint())
                .credentials(properties.getAccessKey(), properties.getSecretKey())
                .build();
    }
}
 
// MinioAutoConfiguration.java
@Configuration
@EnableConfigurationProperties(MinioProperties.class)
@ConditionalOnClass(MinioClient.class)
@ConditionalOnProperty(prefix = "minio", value = "enabled", havingValue = "true")
public class MinioAutoConfiguration {
    @Bean
    public MinioClient minioClient(MinioProperties properties) {
        // 使用配置创建MinioClient Bean
    }
}
 
// MinioProperties.java
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {
    private String endpoint;
    private String accessKey;
    private String secretKey;
    // getters and setters
}
 
// MinioClient.java
public interface MinioClient {
    // 定义Minio客户端操作接口
}
 
// 使用方式
// application.properties
minio.endpoint=http://minio.example.com
minio.access-key=your_access_key
minio.secret-key=your_secret_key
minio.enabled=true
 
// 在Spring Boot应用中
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

在这个简化的例子中，我们定义了一个MinioConfiguration类，它创建了一个MinioClient的Bean。在MinioAutoConfiguration中，我们使用@Conditional注解来检查是否开启了MinIO客户端，并且根据配置文件创建MinioClient Bean。MinioProperties类用于绑定配置文件中的MinIO属性。

这个简化的例子展示了如何创建一个自定义starter，并且如何使用@Conditional注解来控制自动配置的条件。在实际的starter中，你需要提供更多的功能和配置选项。

2024-09-04

在Linux下，使用RPM和YUM是常见的软件安装方式。

RPM包安装：




# 安装软件
sudo rpm -ivh package-name.rpm
 
# 卸载软件
sudo rpm -e package-name
 
# 更新软件
sudo rpm -Uvh package-name.rpm

YUM包安装（推荐，自动解决依赖问题）：




# 安装软件
sudo yum install package-name
 
# 卸载软件
sudo yum remove package-name
 
# 更新软件
sudo yum update package-name

安装JDK：




# 以JDK 8为例
sudo yum install java-1.8.0-openjdk

安装Tomcat：




# 下载Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
 
# 解压
tar -xvf apache-tomcat-9.0.62.tar.gz
 
# 移动到合适的位置
sudo mv apache-tomcat-9.0.62 /opt/tomcat
 
# 启动Tomcat
/opt/tomcat/bin/startup.sh

安装MySQL：




# 安装MySQL服务器
sudo yum install mysql-server
 
# 启动MySQL服务
sudo systemctl start mysqld
 
# 设置MySQL服务开机自启
sudo systemctl enable mysqld
 
# 安全设置（设置root密码等）
mysql_secure_installation

Spring Boot - 在Spring Boot中实现灵活的API版本控制

2024-09-04




import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.addPathPrefix("/api/v{version:[0-9]+}", m -> m.setPattern("/api/v{version:[0-9]+}/**"));
    }
}

这个代码实例展示了如何在Spring Boot中配置路径前缀以实现API版本控制。通过addPathPrefix方法，我们可以定义一个版本号的路径变量，并且指定版本号必须是数字。这样，对于每个API请求，Spring MVC将根据指定的模式去匹配并使用正确的控制器处理请求。这是一个灵活的方式来管理API的版本化，可以在不同版本间共存而不会产生冲突。