分类 java 下的文章

Spring Cloud Security实现权限分配（用户和管理员为例）

2024-09-03




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.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("user").password("{noop}user").roles("USER")
                .and()
                .withUser("admin").password("{noop}admin").roles("USER", "ADMIN");
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/db/**").hasRole("USER")
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
}

这段代码定义了一个简单的Spring Security配置，其中包含了基于内存的用户和角色定义，以及HTTP安全配置。用户"user"被分配了"USER"角色，而"admin"用户除了"USER"角色外，还被赋予了"ADMIN"角色。安全配置中定义了不同URL路径的访问权限和登录页面的设置。

spring boot中使用雪花算法生成雪花ID

2024-09-03

在Spring Boot项目中使用雪花算法生成唯一ID，你可以使用snowflake4j库。首先，你需要在pom.xml中添加依赖：




<dependency>
    <groupId>com.github.theromat</groupId>
    <artifactId>snowflake4j</artifactId>
    <version>1.11.0</version>
</dependency>

然后，你可以创建一个配置类来初始化雪花算法的节点，并提供一个方法来获取ID：




import com.github.theromat.snowflake.Snowflake;
import com.github.theromat.snowflake.SnowflakeFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class SnowflakeConfig {
 
    @Bean
    public Snowflake snowflake() {
        return SnowflakeFactory.create();
    }
}

最后，你可以在任何需要的地方注入Snowflake bean，并使用其nextId方法来生成ID：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    private final Snowflake snowflake;
 
    @Autowired
    public MyService(Snowflake snowflake) {
        this.snowflake = snowflake;
    }
 
    public long generateId() {
        return snowflake.nextId();
    }
}

这样，你就可以在Spring Boot应用中使用雪花算法生成唯一的ID了。

2024-09-03




@Configuration
public class FeignConfig {
 
    @Bean
    public Contract feignContract() {
        return new Contract.Default(); // 使用默认的Contract
    }
 
    @Bean
    public BasicAuthRequestInterceptor basicAuthRequestInterceptor() {
        return new BasicAuthRequestInterceptor("user", "password"); // 基本认证
    }
}
 
@FeignClient(name = "example-service", configuration = FeignConfig.class, url = "http://localhost:8080")
public interface ExampleServiceFeignClient {
 
    @GetMapping("/api/resource")
    String getResource();
}

在这个示例中，我们定义了一个Feign配置类FeignConfig，在这个类中我们定义了一个Bean，这个Bean是Feign的Contract，我们使用的是默认的Contract。同时，我们定义了一个BasicAuthRequestInterceptor Bean，用于Feign请求的基本认证。在ExampleServiceFeignClient接口中，我们指定了Feign客户端的配置为FeignConfig，并且指定了服务的URL。这样，当我们调用getResource方法时，Feign请求会使用基本认证。

2024-09-03

以下是使用Spring Boot整合Kafka发送和接收消息的示例代码：

1. 添加依赖到你的 pom.xml 文件中




<dependencies>
    <!-- Kafka -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>
    <!-- 用于编写消息监听器 -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 配置 application.properties 或 application.yml 文件




# Kafka 基础配置
spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=myGroup
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

3. 发送消息




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
 
@Service
public class KafkaProducer {
 
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
 
    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

4. 接收消息




import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
 
@Component
public class KafkaConsumer {
 
    @KafkaListener(topics = "yourTopic", groupId = "myGroup")
    public void listen(String message) {
        System.out.println("Received message in group myGroup: " + message);
    }
}

5. 使用 KafkaProducer 发送消息




@Autowired
private KafkaProducer kafkaProducer;
 
public void sendMessageExample() {
    kafkaProducer.sendMessage("yourTopic", "Hello, Kafka!");
}

以上代码演示了如何在Spring Boot应用程序中使用KafkaTemplate发送消息，并使用@KafkaListener注解接收消息。记得替换配置文件中的localhost:9092为你的Kafka服务器地址，以及将yourTopic替换为你要监听的主题。

Spring Cloud Feign作为HTTP客户端调用远程HTTP服务

2024-09-03




package com.example.consumer.feign;
 
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
@FeignClient(name = "provider-service", url = "http://localhost:8080")
public interface ProviderFeignClient {
 
    @GetMapping("/provider")
    String getMessage(@RequestParam(value = "name") String name);
}

这个示例代码定义了一个Feign客户端接口ProviderFeignClient，它使用@FeignClient注解指定服务名称和基础URL。然后定义了一个方法getMessage，使用@GetMapping注解指定远程HTTP服务的端点以及参数。这个接口可以被Spring Cloud Feign使用，以简化远程HTTP服务的调用。

Java实战：Spring Boot集成Swagger3

2024-09-03




import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class SwaggerConfig {
 
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("示例应用API")
                        .description("这是一个简单的示例应用API")
                        .version("v1.0.0")
                        .license(new License().name("Apache 2.0").url("http://springdoc.org")));
    }
}

这段代码定义了一个配置类SwaggerConfig，其中包含一个名为customOpenAPI的方法，该方法创建并配置了一个OpenAPI实例，这个实例被用于Swagger的文档信息。在这个例子中，我们设置了API的标题、描述、版本和许可证信息。这是一个简单的配置，可以根据实际需求进行扩展和定制。

2024-09-03

由于篇幅限制，以下是部署Yum、JDK、Nginx、Tomcat、MySQL、EMQX和FTP的核心步骤，包括部分配置步骤。

部署Yum：




# 安装EPEL仓库
yum install epel-release -y
# 清理缓存
yum clean all
# 生成缓存
yum makecache fast

部署JDK：




# 安装OpenJDK
yum install java-1.8.0-openjdk -y

部署Nginx：




# 安装Nginx
yum install nginx -y
# 启动Nginx
systemctl start nginx
# 设置开机自启
systemctl enable nginx

部署Tomcat：




# 安装Tomcat
yum install tomcat -y
# 启动Tomcat
systemctl start tomcat
# 设置开机自启
systemctl enable tomcat

部署MySQL：




# 安装MySQL
yum install mariadb-server mariadb -y
# 启动MySQL
systemctl start mariadb
# 设置开机自启
systemctl enable mariadb
# 安全设置（设置root密码等）
mysql_secure_installation

部署EMQX：




# 导入EMQX公钥
rpm --import https://repos.emqx.io/emqx-ce/linux/centos/EMQX-CE-6.0.0.repo
# 安装EMQX
yum install emqx -y
# 启动EMQX
systemctl start emqx
# 设置开机自启
systemctl enable emqx

部署FTP：




# 安装vsftpd
yum install vsftpd -y
# 启动vsftpd
systemctl start vsftpd
# 设置开机自启
systemctl enable vsftpd

配置部分：




# Nginx配置示例
vim /etc/nginx/conf.d/default.conf
server {
    listen       80;
    server_name  localhost;
 
    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
 
    # 代理Tomcat
    location ~ \.jsp$ {
        proxy_pass http://localhost:8080;
    }
}
 
# MySQL配置示例（设置字符集和大小写敏感性）
vim /etc/my.cnf
[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
 
# EMQX配置示例（更改监听端口和节点名等）
vim /etc/emqx/emqx.conf
listener.tcp.external = 0.0.0.0:1883
node.name = emqx@127.0.0.1
 
# FTP配置示例（设置用户和权限等）
vim /etc/vsftpd/vsftpd.conf
anonymous_enable=NO
local_enable=YES
write_enable=YES
chroot_local_user=YES
useradd -d /home/ftpuser -s /sbin/nologin ftpuser
echo ftpuser:passwd | chpasswd

以上仅为部署和配置的核心步骤，具体配置文件的详细参数和设置需根据实际需求进行调整。

springcloud-fegin 组件调用

2024-09-03

Spring Cloud Feign 是一个声明式的Web服务客户端，它用注解的方式简化了Web服务的调用。

以下是一个使用Spring Cloud Feign的示例：

添加依赖到你的pom.xml：




<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

启动类上添加@EnableFeignClients注解：




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

创建一个Feign客户端接口：




import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
@FeignClient(name = "remote-service", url = "http://localhost:8080")
public interface RemoteServiceClient {
    @GetMapping("/service")
    String getService(@RequestParam(value = "param") String param);
}

使用Feign客户端：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class Controller {
 
    @Autowired
    private RemoteServiceClient remoteServiceClient;
 
    @GetMapping("/call-service")
    public String callService(String param) {
        return remoteServiceClient.getService(param);
    }
}

在这个例子中，RemoteServiceClient是一个Feign客户端接口，用来定义远程服务的调用。当你调用callService方法时，Feign会负责向http://localhost:8080/service发起请求，并将结果返回。

SpringBoot + Poi-tl实现word模板导出数据表格

2024-09-03




import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.data.RowRenderData;
import com.deepoove.poi.data.TableRenderData;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
 
public class WordExportExample {
    public static void main(String[] args) throws Exception {
        // 创建表格数据行
        List<RowRenderData> rows = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            RowRenderData row = RowRenderData.build(
                    TextRenderData.build("单元格1-" + i),
                    TextRenderData.build("单元格2-" + i),
                    TextRenderData.build("单元格3-" + i)
            );
            rows.add(row);
        }
 
        // 创建表格并设置样式
        TableRenderData table = TableRenderData.build(rows)
                .setAlign(TableAlign.CENTER) // 设置表格居中
                .setWidth(8000) // 设置表格宽度
                .setBgColor("f0f0f0"); // 设置背景颜色
 
        // 加载Word模板
        XWPFTemplate template = XWPFTemplate.compile("模板路径.docx");
 
        // 文档替换
        template.render(new HashMap<String, Object>() {{
            put("table", table);
        }});
 
        // 输出到文件
        template.writeAndClose(new FileOutputStream("输出路径.docx"));
    }
}

这段代码展示了如何使用poi-tl库来实现一个简单的Word文档数据表格导出。首先，我们创建了一个表格数据行列表，填充了一些示例数据。接着，我们使用这些数据构建了一个TableRenderData对象，并对表格进行了样式设置。然后，我们加载了一个Word模板，并通过render方法替换了模板中的表格部分。最后，我们将处理后的Word文档保存到了指定的文件路径。