分类 java 下的文章

Spring boot + Mybatis 使用 @Mapper 或 @MapperScan 执行SQL语句

2024-09-04

在Spring Boot项目中使用MyBatis时，可以通过@Mapper或@MapperScan来指定Mapper接口。

使用@Mapper注解：直接在每个Mapper接口上添加@Mapper注解。




@Mapper
public interface UserMapper {
    User selectUserById(int id);
}

使用@MapperScan注解：在Spring Boot启动类或配置类上添加@MapperScan注解，指定需要扫描的Mapper接口所在的包路径。




@SpringBootApplication
@MapperScan("com.example.project.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在上述例子中，无论你选择@Mapper还是@MapperScan，最终你都可以在Service层通过注入Mapper接口来执行SQL语句。




@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
 
    public User getUserById(int id) {
        return userMapper.selectUserById(id);
    }
}

确保你的项目中已经添加了MyBatis和MyBatis-Spring-Boot-Starter依赖。




<!-- 在pom.xml中添加MyBatis依赖 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>

- 阅读更多 -

【Spring Boot】Spring Boot源码解读与原理剖析

System

2024-09-04

所有,java

Spring Boot是一个用于简化Spring应用程序初始搭建以及开发过程的开源框架。它主要关注于快速配置和启动，从而能够让开发者更快地进行业务逻辑的开发。

要解读和剖析Spring Boot的源码，我们可以从以下几个方面入手：

启动流程：了解Spring Boot应用程序如何启动及创建Spring上下文。
自动配置：理解Spring Boot是如何根据类路径上的依赖和属性来自动配置Spring应用程序。
命令行参数：研究Spring Boot如何处理命令行参数，以及它提供的各种配置选项。
Starters：分析Spring Boot Starters是如何简化配置的，以及它们是如何工作的。
Actuator：了解Spring Boot Actuator如何增加生产就绪型应用程序的功能和可视化。

以下是一个简单的Spring Boot应用程序的代码示例：




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

在这个例子中，@SpringBootApplication注解是Spring Boot的核心注解，它是一个组合注解，包含了@EnableAutoConfiguration、@ComponentScan和@Configuration。SpringApplication.run()方法启动了Spring Boot应用程序。

解读和剖析源码需要具体分析Spring Boot的主要类和方法，如SpringApplication、SpringBootServletInitializer、@EnableAutoConfiguration注解处理器等。

在具体分析时，可以使用IDE的调试功能逐步跟踪Spring Boot的启动过程，观察关键对象的创建和配置，这有助于理解Spring Boot的运行机制。

System

2024-09-04

所有,java

解释：

HTTP 403 Forbidden 错误表明客户端的请求已经被服务器接收，但服务器拒绝执行这个请求。在Spring Cloud Gateway的上下文中，这通常是因为请求是跨域的（CORS，Cross-Origin Resource Sharing），而服务器没有正确配置来允许跨域请求。

解决方法：

在Spring Cloud Gateway中添加一个全局的过滤器，用来处理CORS预检请求和实际请求。




@Bean
public CorsWebFilter corsFilter() {
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    config.addAllowedOrigin("*"); // 允许任何源
    config.addAllowedHeader("*"); // 允许任何头
    config.addAllowedMethod("*"); // 允许任何方法
 
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);
 
    return new CorsWebFilter(source);
}

如果你使用的是Spring Boot 2.4.0或更高版本，可以使用新的Spring Security支持来简化CORS配置：




@Bean
public WebFilter corsFilter() {
    return (ServerWebExchange ctx, WebFilterChain chain) -> {
        ServerHttpRequest request = ctx.getRequest();
        if (CorsUtils.isCorsRequest(request)) {
            HttpHeaders requestHeaders = request.getHeaders();
            ServerHttpResponse response = ctx.getResponse();
            HttpMethod requestMethod = requestHeaders.getAccessControlRequestMethod();
            HttpHeaders headers = response.getHeaders();
            headers.setAccessControlAllowOrigin(requestHeaders.getOrigin());
            headers.setAccessControlAllowMethods(List.of(requestMethod.name()));
            headers.setAccessControlAllowCredentials(true);
            headers.setAccessControlAllowHeaders(List.of("Content-Type", "Authorization"));
            headers.setAccessControlMaxAge(1800); // 30 min
            if (request.getMethod() == HttpMethod.OPTIONS) {
                response.setStatusCode(HttpStatus.OK);
                return Mono.empty();
            }
        }
        return chain.filter(ctx);
    };
}

确保在配置中适当设置Access-Control-Allow-Origin，如果需要指定特定的域，可以替换为实际的域地址。

以上代码段配合适当的Spring Cloud Gateway配置应该能够解决跨域问题，允许来自不同源的请求通过Spring Cloud Gateway。

System

2024-09-04

所有,java

Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目提供了一个API网关，它基于Spring 5.0，Spring WebFlux和Project Reactor实现。

Spring Cloud Gateway 的主要目标是为了提供一种简单而有效的方式路由到你的微服务架构。Spring Cloud Gateway 是由Spring Cloud团队提供的一个产品，它使用的是WebFlux中的Reactor模式，以此支持高性能和低延迟。

Spring Cloud Gateway 的核心要点如下：

路由：Spring Cloud Gateway 的基础路由功能，可以通过简单的配置即可实现。




spring:
  cloud:
    gateway:
      routes:
        - id: after_route
          uri: https://example.org
          predicates:
            - Path=/foo/**

断言与过滤器：Spring Cloud Gateway 提供了多种内置的断言和过滤器，同时也支持自定义。




spring:
  cloud:
    gateway:
      routes:
        - id: add_response_header_route
          uri: https://example.org
          predicates:
            - Path=/bar/**
          filters:
            - AddResponseHeader=X-Response-Foo, Bar

负载均衡：Spring Cloud Gateway 支持负载均衡，可以配置不同的负载均衡策略。




spring:
  cloud:
    gateway:
      routes:
        - id: weight_route
          uri: https://example.org
          predicates:
            - Path=/foo/**
          filters:
            - RewritePath=/foo/(?<segment>.*), /$\{segment}
        - id: weight_route
          uri: https://example.org
          predicates:
            - Path=/bar/**
          filters:
            - RewritePath=/bar/(?<segment>.*), /$\{segment}
          metadata:
            weight: 2

服务发现与集成：Spring Cloud Gateway 可以与Spring Cloud服务发现组件（例如Eureka）无缝集成，自动根据服务发现来路由到相应的微服务。




spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          lowerCaseServiceId: true

安全性：Spring Cloud Gateway 支持Spring Security，可以很容易地实现对请求的认证和授权。




spring:
  cloud:
    gateway:
      routes:
        - id: secure_route
          uri: https://example.org
          predicates:
            - Path=/secure/**
          filters:
            - name: Security
              args:
                patterns: /secure/**

限流：Spring Cloud Gateway 支持限流功能，可以配置不同的限流策略。




spring:
  cloud:
    gateway:
      routes:
        - id: request_rate_route
          uri: https://example.org
          predicates:
            - Path=/rate/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 1
                redis-rate-limiter.burstCapacit

- 阅读更多 -

SpringBoot如何配置动态数据源？原理+实战

System

2024-09-04

所有,java

在Spring Boot中配置动态数据源通常涉及以下步骤：

创建一个动态数据源类，比如DynamicDataSource，继承AbstractRoutingDataSource并实现determineCurrentLookupKey方法。
配置至少两个数据源作为动态数据源的目标。
将动态数据源设置为DataSource的目标。
在服务层或者数据访问层通过某种方式（如上下文持有者）切换数据源。

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




import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
public class DynamicDataSource extends AbstractRoutingDataSource {
    private final Map<Object, Object> dynamicTargetDataSources = new ConcurrentHashMap<>();
 
    @Override
    protected Object determineCurrentLookupKey() {
        // 从ThreadLocal中获取数据源标识
        return DataSourceContextHolder.getDataSourceType();
    }
 
    public void addDataSource(String key, DataSource dataSource) {
        this.dynamicTargetDataSources.put(key, dataSource);
        this.setTargetDataSources(dynamicTargetDataSources);
        // 在添加数据源后，需要调用afterPropertiesSet()方法来更新内部的数据源映射
        this.afterPropertiesSet();
    }
}
 
// 数据源上下文持有者
public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
 
    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }
 
    public static String getDataSourceType() {
        return contextHolder.get();
    }
 
    public static void clearDataSourceType() {
        contextHolder.remove();
    }
}
 
// 配置数据源和DynamicDataSource Bean
@Configuration
public class DataSourceConfig {
 
    @Bean
    public DataSource dataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 配置默认数据源
        dynamicDataSource.setDefaultTargetDataSource(primaryDataSource());
        // 初始化时添加其他数据源
        dynamicDataSource.addDataSource("primary", primaryDataSource());
        dynamicDataSource.addDataSource("secondary", secondaryDataSource());
        return dynamicDataSource;
    }
 
    @Bean
    public DataSource primaryDataSource() {
        // 创建并配置主数据源
        return new HikariDataSource();
    }
 
    @Bean
    public DataSource secondaryDataSource() {
        // 创建并配置第二数据源
        return new HikariDataSource();
    }
}
 
// 使用动态数据源
@Service
public class SomeService {
 
    @Autowired
    private JdbcTemplate jdbcTemplate;
 
    public void usePrimaryDataSource() {
        DataSourceContextHolder.setDat

- 阅读更多 -

【Mybatis源码解析】mapper实例化及执行流程源码分析

System

2024-09-04

所有,java




public class MapperInstanceTest {
    // 假设MyBatis版本为3.5.0，以下代码仅为示例，可能需要根据实际版本调整
 
    @Test
    public void testMapperInstanceCreation() throws Exception {
        // 获取Mapper接口的类对象
        Class<?> mapperInterface = MyMapper.class;
        // 获取Mapper接口的类加载器
        ClassLoader classLoader = mapperInterface.getClassLoader();
        // 获取Mapper接口的全限定名
        String className = mapperInterface.getName();
        // 获取代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        // 设置代理超类为Mapper接口
        proxyFactory.setInterfaces(new Class[]{mapperInterface});
        // 设置代理InvocationHandler
        proxyFactory.setInvocationHandler(new MyMapperInvocationHandler());
        // 创建代理类的Class对象
        Class<?> proxyClass = proxyFactory.createClass();
        // 使用反射创建代理实例
        Object mapperProxy = proxyClass.getConstructor().newInstance();
 
        // 以下为验证代理实例是否符合预期
        assertTrue(mapperInterface.isAssignableFrom(mapperProxy.getClass()));
        assertTrue(Proxy.isProxyClass(mapperProxy.getClass()));
 
        // 打印代理类的名称
        System.out.println("代理类名称: " + proxyClass.getName());
    }
 
    // 自定义的InvocationHandler
    private static class MyMapperInvocationHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 实现具体的逻辑
            return null;
        }
    }
 
    // 示例Mapper接口
    public interface MyMapper {
        void myMethod();
    }
}

这个示例代码展示了如何创建一个Mapper接口的代理实例。它使用了JDK动态代理来创建代理类，并验证了代理类是否正确实现了接口。这个过程是MyBatis中实例化Mapper接口的核心步骤之一。

- 阅读更多 -

共同学习|Spring Cloud Alibaba一一Nacos配置

System

2024-09-04

所有,java

在Spring Cloud Alibaba中使用Nacos作为配置中心，你需要做以下几步操作：

引入Nacos客户端依赖
配置Nacos服务器地址
在Nacos中添加配置信息
在Spring应用中加载配置

以下是一个简单的示例：

Step 1: 添加依赖

在pom.xml中添加以下依赖：




<dependencies>
    <!-- Spring Cloud Alibaba Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

Step 2: 配置Nacos服务器地址

在application.properties或application.yml中配置Nacos服务器地址：




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

或者




# application.yml
spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848

Step 3: 在Nacos中添加配置信息

在Nacos控制台中添加配置信息，例如：




Data ID: application.properties
Group: DEFAULT_GROUP
配置内容:
  user.name=Alice
  user.age=30

Step 4: 加载配置

在Spring应用中，你可以使用@Value注解或者@ConfigurationProperties注解来加载配置：




import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
 
@Component
public class UserConfig {
    @Value("${user.name}")
    private String name;
 
    @Value("${user.age}")
    private int age;
 
    // Getters and Setters
}

或者使用配置类：




import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
 
@Component
@ConfigurationProperties(prefix = "user")
public class UserConfig {
    private String name;
    private int age;
 
    // Getters and Setters
}

以上就是使用Spring Cloud Alibaba Nacos作为配置中心的基本步骤和示例代码。

- 阅读更多 -

tomcat---动静分离

System

2024-09-04

所有,java

Tomcat可以通过配置实现动静分离，即将静态资源如HTML、CSS、JavaScript、图片等从Tomcat服务器中分离出来，通常是使用Nginx或者Apache服务器作为静态资源的代理服务器。

以下是一个简单的Nginx配置示例，用于将静态资源的请求代理到Tomcat服务器，而其他请求则直接由Nginx处理：




server {
    listen       80;
    server_name  localhost;
 
    location / {
        root   /path/to/static/resources;
        index  index.html index.htm;
        try_files $uri $uri/ =404;
    }
 
    location ~ \.(jsp|do|action)$ {
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://tomcat_server_ip:tomcat_server_port;
    }
}

在这个配置中：

对于静态资源的请求，Nginx会直接从/path/to/static/resources目录中提供这些资源。
对于以.jsp, .do, .action等结尾的请求（通常是动态资源的请求），Nginx会将请求代理（forward）给Tomcat服务器。

确保将/path/to/static/resources替换为你的静态资源实际存储路径，以及将tomcat_server_ip和tomcat_server_port替换为你的Tomcat服务器的IP地址和端口号。

这样配置后，Nginx会处理静态资源请求，而动态资源请求则转发给Tomcat处理，实现了动静分离。

- 阅读更多 -

SpringBoot 优雅实现超大文件上传，通用方案

System

2024-09-04

所有,java

在Spring Boot中优雅实现超大文件上传，可以使用Spring的MultipartResolver接口和@RequestMapping注解来处理文件上传。以下是一个简单的例子，展示了如何配置Spring Boot以处理大文件上传：

在application.properties或application.yml中配置Multipart解析器的属性，例如设置最大文件大小和内存中的文件大小：




# application.properties
spring.servlet.multipart.max-file-size=128MB
spring.servlet.multipart.max-request-size=128MB
spring.servlet.multipart.enabled=true

创建一个控制器来处理文件上传：




import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
@RestController
public class FileUploadController {
 
    @PostMapping("/upload")
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        // 实现文件保存逻辑
        // 例如：file.transferTo(new File("targetFilePath"));
        return "File uploaded successfully: " + file.getOriginalFilename();
    }
}

如果需要实现进度条或其他上传功能，可以使用第三方库，如Apache Commons FileUpload。

确保服务器配置有足够的资源（内存和磁盘空间）来处理大文件上传。对于超大文件，建议使用分块上传的方式，这样可以减少内存的使用，并允许用户在上传过程中暂停和恢复上传。

System

2024-09-04

所有,java

警告信息："SAX Feature unsupported accessExternalStyles" 通常出现在使用Apache POI处理Excel文件时，尤其是在解析XLSX文件的过程中。这个警告表明程序正在尝试访问XLSX文件中的样式表，但是该操作在当前的SAX解析器上不受支持。

解决方法：

升级Apache POI到最新版本：确保你的项目中使用的Apache POI库是最新版本，因为较新的版本可能已经修复了这个问题。
使用XSSF而非HSSF：如果你正在处理XLSX文件，确保你使用的是XSSF相关的类，而不是旧的HSSF类。XSSF是针对Office Open XML格式（XLSX）的高级API，而HSSF是旧的二进制格式（XLS）的低级API。
修改代码，避免访问样式表：如果你的代码试图访问样式表，但这不是必需的，你可以修改代码，避免这种访问，或者通过自定义的SAX解析器来处理样式表。
使用DOM解析器：如果SAX解析不可避免地需要访问样式表，你可以考虑切换到使用DOM解析器，它可能会更稳定地处理这种复杂的XML结构。

在实施任何解决方案之前，请确保备份你的代码和数据，以防出现不可预见的问题。

- 阅读更多 -