1. 首页
  2. 标签
  3. spring
【重磅】：Spring Initializer 已经不支持Java8，也就是SpringBoot2.x项目初始化
System
2024-09-02
所有,java

Spring Initializer 不再支持 Java 8 是指 Spring Initializr 工具不再提供基于 Java 8 的项目初始化选项。Spring Initializr 是一个 Web 应用程序，用于快速生成 Spring 应用的模板代码。

Spring Boot 2.x 系列不再直接支持 Java 8，而是推荐使用 Java 11 或更高版本。这是因为 Spring Boot 2.x 系列从 2.x 版本开始，弃用了对 Java 8 的支持，并且从 Spring Boot 2.x 的第一个正式版本开始就推荐使用 Java 11 作为最低版本。

解决方法：

  1. 升级你的 Java 版本至 Java 11 或更高。
  2. 使用支持 Java 11 或更高版本的 Spring Initializr 版本来初始化你的项目。

如果你的项目依赖于第三方库，这些库可能还不兼容 Java 11，你可能需要等待这些库更新或者寻找替代方案。

- 阅读更多 -
【深入理解SpringCloud微服务】深入理解nacos
System
2024-09-02
所有,java

Nacos 是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。以下是如何使用 Nacos 的一些基本示例：

  1. 服务注册与发现：



@EnableDiscoveryClient
@SpringBootApplication
public class NacosProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(NacosProviderApplication.class, args);
    }
}

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




spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
  1. 配置管理：



@Configuration
public class NacosConfig {
    @NacosValue(value = "${useLocalCache:false}", autoRefreshed = true)
    private boolean useLocalCache;
 
    // ...
}

在 application.properties 或 application.yml 中配置 Nacos 服务器地址和要管理的配置：




spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=8848
spring.cloud.nacos.config.group=DEFAULT_GROUP
spring.cloud.nacos.config.extension-configs[0].data-id=my-config.properties
spring.cloud.nacos.config.extension-configs[0].group=DEFAULT_GROUP
spring.cloud.nacos.config.extension-configs[0].refresh=true
  1. 动态配置监听：



@Controller
@RequestMapping("/config")
public class ConfigController {
    @NacosValue(value = "${useLocalCache:false}", autoRefreshed = true)
    private boolean useLocalCache;
 
    @GetMapping("/get")
    @ResponseBody
    public boolean getUseLocalCache() {
        return useLocalCache;
    }
}

以上代码展示了如何在 Spring Cloud 应用中使用 Nacos 进行服务注册与发现、配置管理和动态配置监听。在实际应用中，你需要根据具体的业务场景来调整和组合这些特性。

- 阅读更多 -
SpringAOP 面向切面编程
System
2024-09-02
所有,java

Spring AOP（面向切面编程）是一种无侵入的编程方式，它允许你在不修改现有代码的情况下，增加额外的功能，比如日志记录、性能监控、事务管理等。

以下是一个使用Spring AOP记录方法执行时间的简单例子：

  1. 添加依赖到你的 pom.xml：



<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
  1. 创建一个切面类，用于定义切点和通知：



import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class LoggingAspect {
 
    @Pointcut("execution(* com.yourpackage..*.*(..))") // 定义切点，这里是匹配com.yourpackage包下所有方法
    public void serviceMethods(){}
 
    @Around("serviceMethods()") // 环绕切点
    public Object logServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String methodName = methodSignature.getMethod().getDeclaringClass().getSimpleName() + "." + methodSignature.getName();
        
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed(); // 执行方法
        long end = System.currentTimeMillis();
        
        System.out.println("Method " + methodName + " executed in " + (end - start) + "ms");
        return result;
    }
}

在上述代码中，@Pointcut 定义了切点，即哪些方法会被AOP拦截。@Around 注解表示这是一个环绕通知，它会在目标方法执行前后执行额外的逻辑。在这个例子中，我们记录了方法的名称以及执行所需的时间。

确保将 com.yourpackage 替换为你的实际包名。

这个例子展示了如何在不修改原始代码的情况下，记录方法执行的时间。Spring AOP 还可以用于实现更多的横切关注点，例如权限校验、缓存管理、事务管理等。

- 阅读更多 -
springboot之mybatisPlus多表查询及分页查询
System
2024-09-02
所有,java

在Spring Boot项目中使用MyBatis Plus进行多表查询和分页查询，你可以定义相应的Mapper接口并使用MyBatis Plus提供的Wrapper来构建复杂查询条件。以下是一个简单的例子：

  1. 定义Mapper接口：



@Mapper
public interface CustomMapper extends BaseMapper<CustomEntity> {
    IPage<CustomEntity> selectCustomPage(Page<CustomEntity> page, @Param("ew") QueryWrapper<CustomEntity> queryWrapper);
}
  1. 在Service中使用Mapper进行查询：



@Service
public class CustomService {
 
    @Autowired
    private CustomMapper customMapper;
 
    public IPage<CustomEntity> getCustomPage(int current, int size, QueryWrapper<CustomEntity> queryWrapper) {
        Page<CustomEntity> page = new Page<>(current, size);
        return customMapper.selectCustomPage(page, queryWrapper);
    }
}
  1. 构建查询条件并调用Service：



@Autowired
private CustomService customService;
 
public void complexQueryExample() {
    QueryWrapper<CustomEntity> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("field1", value1) // 等于
        .like("field2", value2) // 模糊查询
        .ge("field3", value3) // 大于等于
        .orderByDesc("field4"); // 降序排序
 
    IPage<CustomEntity> page = customService.getCustomPage(1, 10, queryWrapper);
    // 分页查询结果
}

确保你的CustomEntity类映射了数据库表，并且你的CustomMapper位于Spring Boot扫描的包下。以上代码提供了一个多表查询和分页的简单示例，你可以根据实际需求进行扩展和修改。

- 阅读更多 -
SpringCloud | Dubbo 微服务实战——注册中心详解
System
2024-09-02
所有,java

在微服务架构中，服务注册与发现是核心组件之一。Spring Cloud 和 Dubbo 都支持多种注册中心，如Eureka、Consul、Zookeeper等。

Spring Cloud 注册中心详解

Spring Cloud 使用Eureka作为默认注册中心。以下是Eureka Server的配置示例：




@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

在application.properties中配置Eureka Server：




spring.application.name=eureka-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

Dubbo 注册中心详解

Dubbo 可以使用Zookeeper作为注册中心。以下是Dubbo Provider的配置示例：




<dubbo:application name="demo-provider"/>
<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
<dubbo:protocol name="dubbo" port="20880"/>
<dubbo:service interface="com.example.DemoService" ref="demoService"/>

在上述配置中，<dubbo:application>标签定义了应用名称，<dubbo:registry>标签指定注册中心地址，<dubbo:protocol>标签定义服务提供者的通信协议和端口，<dubbo:service>标签暴露服务。

注册中心是微服务架构中的关键组件，Spring Cloud和Dubbo都提供了灵活的支持，可以根据具体需求选择合适的注册中心实现。

- 阅读更多 -
【Tomcat与网络1】史前时代—没有Spring该如何写Web服务
System
2024-09-02
所有,java

在史前时代，在Servlet API和JSP之前，编写Web服务可能就像下面这样简单：




import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
 
public class HelloWorldServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        response.setContentType("text/plain");
        PrintWriter out = response.getWriter();
        out.println("Hello, world!");
    }
}

在这个简单的例子中，我们创建了一个HelloWorldServlet类，它扩展了HttpServlet类，并覆盖了doGet方法来处理HTTP GET请求。当服务收到一个GET请求时，它会响应一个简单的文本"Hello, world!"。这个例子展示了在没有Spring或其他框架的情况下，如何编写基本的Web服务。

- 阅读更多 -
SpringBoot +Redis/Guava 实现布隆过滤器
System
2024-09-02
所有,java



import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
 
import javax.annotation.PostConstruct;
 
@Component
public class BloomFilterHelper {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    private ValueOperations<String, String> opsForValue;
 
    private BloomFilter<Integer> bloomFilter;
 
    @PostConstruct
    private void init() {
        opsForValue = redisTemplate.opsForValue();
        bloomFilter = BloomFilter.create(Funnels.integerFunnel(), 1000000, 0.01);
 
        // 如果已有布隆过滤器数据，则重新构建布隆过滤器
        String bloomFilterData = opsForValue.get("bloomFilterData");
        if (bloomFilterData != null) {
            bloomFilterData.split(",").forEach(number -> bloomFilter.put(Integer.parseInt(number)));
        }
    }
 
    public boolean mightContain(int value) {
        return bloomFilter.mightContain(value);
    }
 
    public void put(int value) {
        bloomFilter.put(value);
        opsForValue.set("bloomFilterData", String.join(",", bloomFilter.asSet().stream().map(Object::toString).collect(Collectors.toList())));
    }
}

这个代码示例使用了Guava的BloomFilter类来创建布隆过滤器，并且将其存储在Redis中。mightContain方法用于检查元素是否可能存在于布隆过滤器中，而put方法用于将元素添加到布隆过滤器中并更新Redis中的数据。这个示例展示了如何在Spring Boot应用中使用布隆过滤器，并且如何通过Redis来持久化布隆过滤器的数据。

- 阅读更多 -
3.Spring Cloud LoadBalancer 入门与使用 ★ ✔【自带的负载均衡设置（轮询、随机）、Nacos自带的负载均衡设置（权重）、缓存的开启】
System
2024-09-02
所有,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 String choose() {
        ServiceInstance instance = loadBalancerClient.choose("service-id");
        return instance.getUri().toString();
    }
}

这段代码演示了如何在Spring Cloud应用中使用LoadBalancerClient来选择一个服务实例。loadBalancerClient.choose("service-id")方法会根据提供的服务ID选择一个实例，并返回包含该实例信息的ServiceInstance对象。然后，通过这个实例的URI属性获取实例的地址，并返回它。这个过程是Spring Cloud Netflix Ribbon与Eureka结合使用实现自动负载均衡的一个例子。

- 阅读更多 -
Spring Boot 整合 Dubbo3 + Nacos 2.4.0【进阶】+ 踩坑记录
System
2024-09-02
所有,java

由于篇幅限制，我们将提供一个简化的Dubbo3与Nacos2.4.0整合的代码示例，并附上重要的配置和解决常见问题的指导。




# application.yml
spring:
  application:
    name: dubbo3-nacos-demo
 
dubbo:
  applications:
    demo-application:
      name: demo-application
  registry:
    address: "nacos://127.0.0.1:8848"
  protocol:
    name: dubbo
    port: -1
  scan:
    base-packages: com.example.service
 
management:
  endpoints:
    web:
      exposure:
        include: '*'



// Provider配置类
@Configuration
public class DubboConfig {
 
    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("demo-application");
        return applicationConfig;
    }
 
    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setAddress("nacos://127.0.0.1:8848");
        return registryConfig;
    }
 
    @Bean
    public ProtocolConfig protocolConfig() {
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(-1);
        return protocolConfig;
    }
}



// 服务提供者接口
public interface GreetingService {
    String sayHello(String name);
}
 
// 服务提供者实现
@DubboService(version = "1.0.0")
public class GreetingServiceImpl implements GreetingService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

注意：

  • 确保Nacos服务器正常运行并可以访问。
  • 检查Dubbo和Nacos的版本兼容性。
  • 如果遇到问题，可以通过查看Dubbo和Nacos的日志来进行故障排除。

这个示例展示了如何在Spring Boot应用中配置Dubbo3和Nacos2.4.0。通过配置文件和配置类，我们定义了应用名、注册中心地址和协议类型。服务提供者接口和实现则演示了如何标记服务并暴露给注册中心。这个简化的示例旨在教育开发者如何开始使用Dubbo3和Nacos进行分布式服务开发。

- 阅读更多 -
【SpringBoot】SpringBoot内置Servlet容器源码分析-Tomcat
System
2024-09-02
所有,java

Spring Boot 使用内嵌的 Servlet 容器，默认使用 Tomcat。下面是 Spring Boot 启动内嵌 Tomcat 容器的核心源码解析：

  1. SpringBootServletContainer：这是Spring Boot用来启动内嵌Tomcat的主要类。它负责配置和启动Tomcat服务器。



public class SpringBootServletContainer {
 
    // ... 省略其他代码 ...
 
    public SpringBootServletContainer(ServletContextInitializer... initializers) {
        this.initializers = initializers;
    }
 
    public void start() throws ServletException {
        // 创建Tomcat服务器
        Tomcat tomcat = new Tomcat();
 
        // 设置Tomcat的相关基础配置，如端口号、应用路径等
        // ... 省略具体配置代码 ...
 
        // 添加Web应用
        tomcat.addWebapp(tomcat.getHost().getName(), new File(contextPath).getAbsolutePath());
 
        // 为Tomcat的StandardContext设置ServletContextInitializer
        // ... 省略设置ServletContextInitializer代码 ...
 
        // 启动Tomcat服务器
        tomcat.start();
 
        // ... 省略其他代码 ...
    }
 
    // ... 省略其他代码 ...
}
  1. TomcatEmbeddedServletContainerFactory：这是创建内嵌Tomcat容器的工厂类，Spring Boot通过它来定制化Tomcat容器的行为。



public class TomcatEmbeddedServletContainerFactory {
 
    // ... 省略其他代码 ...
 
    public EmbeddedServletContainer getEmbeddedServletContainer(
            Tomcat tomcat, ServletContextInitializer... initializers) {
 
        // 为Tomcat设置配置，如错误页面、MIME类型和连接器等
        // ... 省略具体配置代码 ...
 
        // 添加ServletContextInitializer到Tomcat
        // ... 省略添加ServletContextInitializer代码 ...
 
        // 返回一个代表内嵌Tomcat容器的EmbeddedServletContainer实例
        // ... 省略返回实例的代码 ...
    }
 
    // ... 省略其他代码 ...
}
  1. SpringApplication：在Spring Boot应用的main方法中，它负责启动Spring Boot应用。



public class SpringApplication {
 
    // ... 省略其他代码 ...
 
    public ConfigurableApplicationContext run(String... args) {
        // ... 省略Spring应用上下文的启动代码 ...
 
        // 创建内嵌Servlet容器
        // ... 省略创建内嵌Servlet容器的代码 ...
 
        // 启动内嵌Servlet容器
        // ... 省略启动内嵌Servlet容器的代码 ...
 
        // ... 省略其他代码 ...
    }
 
    // ... 省略其他代码 ...
}

以上代码片段展示了Spring Boot内嵌Tomcat的核心逻辑，实际的实现细节需要查看Spring Boot的官方源码来获取。

- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号