标签 spring 下的文章

Spring MVC 之 Restful 风格请求⽀持

2024-09-05




import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
@RestController
@RequestMapping("/api/items")
public class ItemController {
 
    // 假设这是一个服务组件，用于处理业务逻辑
    @Autowired
    private ItemService itemService;
 
    // 获取所有商品列表（Restful风格的查询所有）
    @GetMapping
    public ResponseEntity<List<Item>> queryAllItems() {
        List<Item> items = itemService.queryAll();
        if (items.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        return new ResponseEntity<>(items, HttpStatus.OK);
    }
 
    // 根据关键字查询商品列表（Restful风格的查询）
    @GetMapping("/search")
    public ResponseEntity<List<Item>> searchItemsByKeyword(@RequestParam String keyword) {
        List<Item> items = itemService.searchByKeyword(keyword);
        if (items.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        return new ResponseEntity<>(items, HttpStatus.OK);
    }
 
    // 根据ID查询商品详情（Restful风格的查询单个）
    @GetMapping("/{id}")
    public ResponseEntity<Item> queryItemById(@PathVariable("id") Integer id) {
        Item item = itemService.queryById(id);
        if (item == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(item, HttpStatus.OK);
    }
}

这个代码示例展示了如何在Spring MVC中使用@RestController和@GetMapping注解来创建支持Restful风格的控制器。它提供了三个基本的Restful操作：获取所有商品列表、根据关键字查询商品列表和根据ID查询商品详情。对于查询操作，它返回了相应的HTTP状态码，如HttpStatus.OK或HttpStatus.NO_CONTENT，以表示请求的结果。

2024-09-05




// 假设已经有一个Protobuf定义的消息，例如：
// message Person {
//   string name = 1;
//   int32 age = 2;
// }
 
// 在Spring Boot中配置Protobuf支持
@Configuration
public class ProtobufConfiguration {
 
    @Bean
    public ProtobufHttpMessageConverter protobufHttpMessageConverter() {
        return new ProtobufHttpMessageConverter();
    }
}
 
// 使用Protobuf进行数据序列化和反序列化的Controller
@RestController
public class ProtobufController {
 
    // 将HTTP请求的Protobuf消息转换为Java对象
    @PostMapping(path = "/person", consumes = "application/x-protobuf")
    public Person postPerson(@RequestBody Person person) {
        // 处理接收到的Person对象
        return person; // 假设处理后不变，直接返回
    }
 
    // 将Java对象序列化为Protobuf消息，并作为HTTP响应返回
    @GetMapping(path = "/person/{id}", produces = "application/x-protobuf")
    public ResponseEntity<Person> getPerson(@PathVariable("id") int id) {
        Person person = ...; // 获取Person对象
        return ResponseEntity.ok(person);
    }
}

这个简单的例子展示了如何在Spring Boot应用程序中配置Protobuf消息转换器，并在Controller中使用Protobuf进行数据的序列化和反序列化。在实际应用中，你需要定义相应的Protobuf消息类型，并确保Person类是根据你的.proto文件自动生成的。

Spring Boot中使用JWT及拦截器配置以及各层次的介绍

2024-09-05




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import com.example.demo.security.jwt.JwtAuthenticationFilter;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Bean
    JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter();
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // 其他配置 ...
            .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
            // 其他配置 ...
    }
}

这段代码定义了一个SecurityConfig类，继承自WebSecurityConfigurerAdapter。它创建了一个JwtAuthenticationFilter的Bean，并在configure方法中将其添加到Spring Security的过滤器链中，并指定它在UsernamePasswordAuthenticationFilter之前。这样配置后，JWT认证过滤器会在用户名密码认证过滤器之前执行，用于处理和验证JWT token。

基于Spring Cloud Alibaba的微服务云原生化的详细设计

2024-09-05

以下是一个基于Spring Cloud Alibaba构建微服务的简化版本的核心配置示例：




# 服务注册与发现
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # Nacos Server 地址
 
# 配置管理
spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848 # Nacos Server 地址
        namespace: 0076e04f-5d07-44b7-b8d7-5b52179df666 # Nacos 命名空间，可选
        group: DEFAULT_GROUP # Nacos 配置分组，可选
        file-extension: yaml # 配置文件扩展名，可选
 
# 服务间调用
feign:
  hystrix:
    enabled: true # 开启feign的hystrix支持
 
# 熔断器
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000 # 设置Hystrix的超时时间
 
# 服务限流和熔断
feign:
  hystrix:
    enabled: true # 开启Feign的Hystrix支持
 
# 服务网关
spring:
  cloud:
    gateway:
      routes:
        - id: user_service
          uri: lb://user-service # 用户服务的路由地址
          predicates:
            - Path=/user/** # 匹配路径的规则
          filters:
            - StripPrefix=1 # 去掉路径的第一部分
 
# 分布式配置中心
spring:
  cloud:
    config:
      discovery:
        enabled: true # 开启基于服务发现的配置
        service-id: config-server # 配置中心服务ID
 
# 分布式服务跟踪
spring:
  sleuth:
    sampler:
      probability: 1.0 # 跟踪采样率，1.0表示全部跟踪
 
# 监控
management:
  endpoints:
    web:
      exposure:
        include: '*' # 暴露所有管理端点
  endpoint:
    health:
      show-details: always # 总是显示健康详情

这个配置文件展示了如何将Spring Cloud Alibaba的各个组件整合到一个微服务架构中，包括服务注册与发现（Nacos Discovery）、配置管理（Nacos Config）、服务间调用（Feign）、熔断器（Hystrix）、服务网关（Spring Cloud Gateway）、分布式配置中心和分布式服务跟踪（Spring Cloud Sleuth）等。这为开发者提供了一个清晰的微服务架构的设计和配置示例。

Spring Cloud构建微服务架构服务注册与发现，意外收获字节跳动内部资料

2024-09-05

在Spring Cloud中，服务注册与发现通常使用Eureka来实现。以下是一个简单的例子：

添加依赖到pom.xml：




<dependencies>
    <!-- Spring Cloud Eureka Server -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

配置application.yml：




server:
  port: 8761
 
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类添加@EnableEurekaServer注解：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

以上代码创建了一个简单的Eureka服务注册中心。服务提供者和服务消费者将会在这里注册并且相互发现。这是微服务架构中一个非常关键的部分。

2024-09-05




import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.springframework.boot.web.embedded.jetty.JettyServerCustomizer;
import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class JettyConfig {
 
    @Bean
    public WebServerFactoryCustomizer<JettyServletWebServerFactory> jettyWebServerFactoryCustomizer() {
        return server -> server.addServerCustomizers(jettyServerCustomizer());
    }
 
    @Bean
    public JettyServerCustomizer jettyServerCustomizer() {
        return server -> {
            QueuedThreadPool threadPool = new QueuedThreadPool();
            threadPool.setMinThreads(20); // 设置最小线程数
            threadPool.setMaxThreads(100); // 设置最大线程数
            threadPool.setIdleTimeout(60000); // 设置线程空闲超时时间（毫秒）
            server.setThreadPool(threadPool);
        };
    }
}

这段代码演示了如何在Spring Boot应用中配置Jetty服务器的线程池。首先，我们创建了一个JettyServletWebServerFactory的定制器，并向其中添加了一个自定义的JettyServerCustomizer。在自定义器中，我们创建了一个QueuedThreadPool实例，并设置了它的最小、最大线程数和空闲超时时间。然后，我们将这个线程池设置为Jetty服务器的线程池。这样，我们就可以根据应用的需求对Jetty的线程池进行定制。

2024-09-05




import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.oauth2.server.authorization.client.InMemoryRegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClient;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository;
 
@Configuration
public class RegisteredClientConfiguration {
 
    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("client-id")
                .clientSecret("client-secret")
                .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
                .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
                .redirectUri("http://127.0.0.1:8080/login/oauth2/code/custom-client")
                .scope(OidcScopes.OPENID)
                .scope("email")
                .scope("profile")
                .clientSettings(ClientSettings.builder()
                        .requireAuthorizationConsent(true)
                        .build())
                .build();
 
        return new InMemoryRegisteredClientRepository(registeredClient);
    }
}

这段代码定义了一个RegisteredClientConfiguration配置类，它创建了一个内存中的RegisteredClientRepository，并注册了一个新的客户端。这个客户端支持基本的认证方法，可以使用授权码流程和刷新令牌。它还定义了客户端需要请求的作用域和重定向URI。这个配置类可以作为Spring Security OAuth2 Authorization Server配置的一部分，帮助示例应用程序正确地管理客户端和授权信息。

SpringBoot Web开发（请求，响应，分层解耦）

2024-09-05




import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
@RequestMapping("/api")
public class ApiController {
 
    private final Service service;
 
    public ApiController(Service service) {
        this.service = service;
    }
 
    @GetMapping("/greeting")
    @ResponseBody
    public Greeting greeting() {
        return service.greet();
    }
}
 
// Service.java
public interface Service {
    Greeting greet();
}
 
// ServiceImpl.java
import org.springframework.stereotype.Service;
 
@Service
public class ServiceImpl implements Service {
    @Override
    public Greeting greet() {
        return new Greeting("Hello, Spring Boot!");
    }
}
 
// Greeting.java
public class Greeting {
    private final String content;
 
    public Greeting(String content) {
        this.content = content;
    }
 
    public String getContent() {
        return content;
    }
}

在这个简化的代码示例中，我们创建了一个名为ApiController的Spring Boot控制器，它处理对/api/greeting的GET请求。它使用依赖注入的Service实例来处理请求，并返回一个简单的问候Greeting对象作为JSON响应。这个例子展示了如何在Spring Boot应用中实现请求处理、服务层的定义以及响应的生成，体现了分层架构的概念。

2024-09-05

在Spring Cloud环境下，结合Spring Cloud+MyBatis Plus+DynamicDataSource多数据源动态切换、分布式数据库事务，可以使用下面的示例代码来实现：

配置多数据源：




spring:
  datasource:
    dynamic:
      primary: db1 # 设置主数据源
      strict: false # 开启严格模式, 默认false不启用, 启用则未配置的数据源不允许使用
      datasource:
        db1:
          url: jdbc:mysql://localhost:3306/db1
          username: root
          password: 
          driver-class-name: com.mysql.cj.jdbc.Driver
        db2:
          url: jdbc:mysql://localhost:3306/db2
          username: root
          password: 
          driver-class-name: com.mysql.cj.jdbc.Driver

配置DynamicDataSource：




@Configuration
@MapperScan(basePackages = "你的mapper包路径", sqlSessionFactoryRef = "sqlSessionFactory")
public class DynamicDataSourceConfig {
 
    @Primary
    @Bean
    public DataSource dynamicDataSource(@Qualifier("db1") DataSource db1,
                                       @Qualifier("db2") DataSource db2) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setDefaultTargetDataSource(db1); // 设置默认数据源
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("db1", db1);
        dataSourceMap.put("db2", db2);
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        return dynamicDataSource;
    }
 
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dynamicDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dynamicDataSource);
        return sqlSessionFactoryBean.getObject();
    }
}

动态数据源切换：




public class DynamicDataSourceContextHolder {
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
 
    public static void setDataSource(String dataSource) {
        CONTEXT_HOLDER.set(dataSource);
    }
 
    public static String getDataSource() {
        return CONTEXT_HOLDER.get();
    }
 
    public static void clearDataSource() {
        CONTEXT_HOLDER.remove();
    }
}

在服务调用时，通过DynamicDataSourceContextHolder.setDataSource("数据源名")来切换数据源。

分布式事务管理：

确保你的Spring Cloud版本支持分布式事务，并且使用了如Rabbit