标签 spring 下的文章

2024-09-06

在Spring Cloud中，使用Nacos作为服务注册中心和配置中心，可以很容易地搭建起服务的集群和使用Feign进行服务间调用。以下是简要步骤和示例代码：

准备Nacos Server集群环境。
在application.properties或application.yml中配置Nacos Server集群地址。
使用@EnableDiscoveryClient注解开启服务注册发现。
使用Feign客户端进行服务间调用。

以下是相关配置和示例代码：

application.yml配置Nacos集群：




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # Nacos Server集群地址，多个地址以逗号分隔
        namespace: 命名空间ID # 如果使用的是命名空间，需要配置此项
        cluster-name: 集群名称 # 如果指定集群，需要配置此项

服务注册发现与Feign客户端使用：




@EnableDiscoveryClient // 开启服务注册发现
@EnableFeignClients // 开启Feign客户端支持
public class Application {
    // ...
}
 
@FeignClient("服务名") // 指定Feign客户端调用的服务名
public interface MyFeignClient {
    @GetMapping("/api/method")
    String methodName(@RequestParam("param") String param);
}

以上代码展示了如何配置Nacos作为服务注册中心，并使用Feign客户端进行服务间调用。在实际部署时，确保Nacos Server集群的高可用性和网络分区隔离。

- 阅读更多 -

Spring Boot--Freemarker渲染技术+实际案例

System

2024-09-06

所有,java

在Spring Boot项目中，我们可以使用Freemarker来渲染页面。Freemarker是一个Java模板引擎，它能够生成文本输出，例如HTML、XML、电子邮件等。

以下是一个简单的例子，展示如何在Spring Boot项目中集成Freemarker：

在pom.xml中添加Freemarker依赖：




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

创建一个Controller来处理请求并返回模板视图名：




@Controller
public class HelloController {
 
    @GetMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("name", "World");
        return "hello"; // 对应src/main/resources/templates/hello.ftl
    }
}

在src/main/resources/templates目录下创建Freemarker模板文件hello.ftl：




<!DOCTYPE html>
<html>
<head>
    <title>Hello</title>
</head>
<body>
    <h1>Hello, ${name}!</h1>
</body>
</html>

当你访问/hello路径时，Controller会返回hello.ftl模板，并将"World"传递给该模板作为name变量。Freemarker将使用传递的数据替换模板中的变量，最终生成HTML并返回给客户端。

这个例子展示了如何在Spring Boot中集成Freemarker，并实现了一个简单的页面渲染功能。在实际的应用场景中，你可以根据需要将数据库查询结果、服务调用结果等传递给模板，动态生成页面内容。

- 阅读更多 -

SpringBoot集成Flowable工作流

System

2024-09-06

所有,java

Spring Boot 整合 Flowable 工作流的方法主要包括以下几个步骤：

在 Spring Boot 项目的 pom.xml 文件中添加 Flowable 相关依赖。
配置数据源和 Flowable 相关配置。
创建配置类，初始化流程引擎。
使用 Flowable API 进行工作流的开发。

以下是一个简单的例子：

pom.xml 添加依赖




<dependencies>
    <!-- Flowable 工作流引擎 -->
    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-spring-boot-starter</artifactId>
        <version>6.7.2</version>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>

application.properties 或 application.yml 配置数据源和Flowable




# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/flowable?useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
# Flowable 配置
spring.flowable.database-schema-update=true
spring.flowable.async-executor-enabled=false
spring.flowable.job-executor-enabled=false

FlowableConfig 配置类




import org.flowable.spring.SpringProcessEngineConfiguration;
import org.flowable.spring.boot.EngineConfigurationConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
 
@Configuration
public class FlowableConfig implements EngineConfigurationConfigurer<SpringProcessEngineConfiguration> {
 
    @Bean
    public Resource[] deploymentResources() {
        // 返回bpmn和png部署文件资源
    }
 
    @Override
    public void configure(SpringProcessEngineConfiguration engineConfiguration) {
        // 可以在这里进行自定义配置
    }
}

使用 Flowable API 进行工作流部署和操作




import org.flowable.engine.RepositoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.repository.Deployment;
import org.flowable.engine.runtime.ProcessInstance;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class WorkflowService {
 
    @Autowired
    private RepositoryService repositoryService;
 
    @Autowired
    private RuntimeService runtimeService;
 
    public void deployProcess() {
        Deployment deployment = repositoryService.createDeployment()
                .addResourcesFromResourceIds("bpmnFileResourceId", "pngFileResourceId")
                .deploy();
        System.out.println("流程定义ID:" + deployment.getId());
    }
 
    public void startPr

- 阅读更多 -

Spring Cloud LoadBalancer基础入门与应用实践

System

2024-09-06

所有,java




import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;
 
@RestController
public class LoadBalancerController {
 
    @Autowired
    private LoadBalancerClient loadBalancerClient;
 
    @GetMapping("/choose")
    public ServiceInstance chooseServiceInstance() {
        // 使用LoadBalancerClient选择服务实例
        return loadBalancerClient.choose("service-id");
    }
}

这段代码演示了如何在Spring Cloud应用中使用LoadBalancerClient来选择一个特定服务的实例。chooseServiceInstance方法通过传入服务的标识符"service-id"来选择一个实例，并返回该实例的信息。这个过程是负载均衡的一个基本实现，通常在微服务架构中用来进行服务间的调用。

System

2024-09-06

所有,java

Spring Boot和Spring Cloud项目中的application.properties或application.yml配置文件用于配置应用程序的各种属性，比如服务的端口号、数据库连接信息、特定功能的开关等。

application.properties的例子：




server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypass

application.yml的例子：




server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: mypass

这些配置文件可以根据不同的部署环境（开发、测试、生产等）进行定制，通常通过设置不同的配置文件后缀来实现，例如：application-dev.properties，application-test.yml。Spring Boot会根据spring.profiles.active属性来选择加载对应的配置文件。

System

2024-09-06

所有,java




import io.undertow.Undertow;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.context.annotation.Bean;
 
@SpringBootApplication
public class UndertowExampleApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(UndertowExampleApplication.class, args);
    }
 
    @Bean
    public ConfigurableServletWebServerFactory webServerFactory() {
        UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();
        factory.addBuilderCustomizers(builder -> 
            builder.setServerOption(Undertow.BUFFER_POOL, new ByteBufferPoolBuilder().build())
        );
        return factory;
    }
}

这段代码演示了如何在Spring Boot应用程序中配置Undertow作为嵌入式服务器。通过定义一个webServerFactory的Bean，我们可以自定义Undertow的设置，例如设置缓冲池选项。这是一个简化的例子，实际应用中可以根据需要进行更多的自定义配置。

- 阅读更多 -

springboot+mybatis-plus+多源事务

System

2024-09-06

所有,java

在Spring Boot项目中使用MyBatis-Plus进行多数据源配置时，可以通过以下步骤实现：

配置多个数据源
配置多个SqlSessionFactory和SqlSessionTemplate
配置事务管理器，确保每个数据源有对应的事务管理

以下是一个简化的示例配置：




@Configuration
public class DataSourceConfig {
 
    @Bean
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    public SqlSessionFactory primarySqlSessionFactory(@Qualifier("primaryDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }
 
    @Bean
    public SqlSessionFactory secondarySqlSessionFactory(@Qualifier("secondaryDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }
 
    @Bean
    public SqlSessionTemplate primarySqlSessionTemplate(@Qualifier("primarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
 
    @Bean
    public SqlSessionTemplate secondarySqlSessionTemplate(@Qualifier("secondarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
 
    @Bean(name = "primaryTransactionManager")
    public PlatformTransactionManager primaryTransactionManager(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
 
    @Bean(name = "secondaryTra

- 阅读更多 -

SpringBoot 接口加密解密，新姿势！

System

2024-09-06

所有,java

在Spring Boot中实现接口加密解密，可以通过自定义一个过滤器来拦截请求并进行加解密处理。以下是一个简单的示例：

创建一个加解密的工具类，例如AESUtil.java。




public class AESUtil {
    private static final String KEY = "1234567890123456"; // 示例密钥
 
    public static String encrypt(String content) {
        // 加密逻辑
        // ...
        return content; // 示例返回原文
    }
 
    public static String decrypt(String content) {
        // 解密逻辑
        // ...
        return content; // 示例返回原文
    }
}

创建一个过滤器，拦截请求并进行加解密处理。




@Component
public class EncryptFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        String body = getRequestBody(req);
        if (body != null) {
            // 解密请求体
            String decryptedBody = AESUtil.decrypt(body);
            // 重新设置解密后的请求体
            // ...
        }
        // 继续执行过滤器链
        chain.doFilter(request, response);
    }
 
    private String getRequestBody(HttpServletRequest request) {
        // 获取请求体逻辑
        // ...
        return null; // 示例返回null
    }
}

在Spring Boot的配置类中注册过滤器。




@Configuration
public class FilterConfig {
 
    @Bean
    public FilterRegistrationBean registerEncryptFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new EncryptFilter());
        registration.addUrlPatterns("/*"); // 拦截所有请求
        registration.setOrder(1);
        return registration;
    }
}

这样就可以实现接口加密解密的需求。记得在实际应用中替换加解密逻辑，并处理好请求体的设置和获取。

- 阅读更多 -

SpringCloud系列：负载均衡组件-Ribbon

System

2024-09-06

所有,java

Ribbon是一个基于HTTP和TCP的客户端负载均衡器，它是Spring Cloud Netflix模块中的一部分。Ribbon可以在客户端配置服务提供者地址后，通过负载均衡策略来选择服务提供者实例，从而实现客户端的负载均衡。

以下是一个使用Ribbon实现负载均衡的简单示例：

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




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

配置服务提供者地址列表，通常在application.properties或application.yml中配置：




# application.properties
service.ribbon.listOfServers = \
  http://server1:8000, \
  http://server2:8000, \
  http://server3:8000

使用RestTemplate进行服务调用，Ribbon会自动应用负载均衡策略：




@Bean
@LoadBalanced
RestTemplate restTemplate() {
    return new RestTemplate();
}
 
public class SomeService {
 
    @Autowired
    private RestTemplate restTemplate;
 
    public String callService() {
        return restTemplate.getForObject("http://SERVICE-NAME/some-endpoint", String.class);
    }
}

在上述代码中，@LoadBalanced注解使得RestTemplate与Ribbon集成，并且使用http://SERVICE-NAME/some-endpoint的方式调用服务时，Ribbon会根据配置的服务名来选择合适的服务实例。

注意：SERVICE-NAME是指服务提供者在Ribbon中注册的名称，它应与service.ribbon.listOfServers中的配置相对应。

- 阅读更多 -

spring cloud框架之健康检查（多数据源场景）

System

2024-09-06

所有,java




import org.springframework.boot.actuate.health.CompositeHealthIndicator;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.health.Status;
import org.springframework.stereotype.Component;
 
import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;
 
@Component
public class CustomHealthIndicator extends CompositeHealthIndicator {
 
    private final HealthIndicator db1HealthIndicator;
    private final HealthIndicator db2HealthIndicator;
 
    public CustomHealthIndicator(HealthIndicator db1HealthIndicator, HealthIndicator db2HealthIndicator) {
        this.db1HealthIndicator = db1HealthIndicator;
        this.db2HealthIndicator = db2HealthIndicator;
    }
 
    @PostConstruct
    private void initialize() {
        // 注册健康指标，可以通过这种方式为不同的数据源定义健康指标
        healthIndicators().put("db1", db1HealthIndicator);
        healthIndicators().put("db2", db2HealthIndicator);
    }
 
    @Override
    protected Map<String, HealthIndicator> getHealthIndicators() {
        return healthIndicators();
    }
 
    private Map<String, HealthIndicator> healthIndicators() {
        // 这里可以根据实际情况动态初始化健康指标
        return new HashMap<>();
    }
 
    @Override
    public Health health() {
        // 这里可以自定义返回的健康信息，比如返回所有数据源的状态
        int upCount = 0;
        Map<String, Health> healths = new HashMap<>();
        for (Map.Entry<String, HealthIndicator> entry : getHealthIndicators().entrySet()) {
            Health health = entry.getValue().health();
            healths.put(entry.getKey(), health);
            if (health.getStatus().equals(Status.UP)) {
                upCount++;
            }
        }
        // 假设如果任何一个数据源是DOWN，则整个服务状态是DOWN
        Status status = (upCount == 0) ? Status.DOWN : Status.UP;
        return new Health.Builder(status, healths).build();
    }
}

这个代码示例展示了如何在Spring Cloud应用中定义一个自定义的健康指标，用于监控多个数据源。在这个例子中，我们创建了一个CustomHealthIndicator类，它继承自CompositeHealthIndicator。在初始化方法中，我们注册了两个健康指标，分别对应两个数据源。在health方法中，我们自定义了返回的健康信息，通过遍历所有的健康指标，我们可以返回每个数据源的健康状态，并且可以设置整体服务的健康状态。

- 阅读更多 -