分类 java 下的文章

2024-09-04

在Linux系统中，如果你想在同一个Tomcat服务器下使用不同的端口号访问不同的项目，你可以通过配置多个Tomcat实例或修改现有实例的配置来实现。

以下是配置不同项目使用不同端口号的步骤：

为每个项目创建一个单独的webapps目录，用于存放项目文件。
修改conf/server.xml文件，为每个项目配置不同的Connector端口。
确保防火墙设置允许对应端口的流量通过。

以下是一个简单的例子：

假设你有两个项目project1和project2，你想要project1使用8080端口访问，project2使用8081端口访问。

为两个项目创建两个不同的webapps目录：




mkdir /path/to/tomcat/project1_webapps
mkdir /path/to/tomcat/project2_webapps

修改conf/server.xml文件，在<Service>标签中为每个项目配置不同的Connector端口：




<Service name="Catalina">
  <!-- Project 1 on port 8080 -->
  <Connector port="8080" protocol="HTTP/1.1"
             connectionTimeout="20000"
             redirectPort="8443" />
  <Engine name="Catalina" defaultHost="localhost">
    <Realm className="org.apache.catalina.realm.LockOutRealm">
      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
             resourceName="UserDatabase"/>
    </Realm>
    <Host name="localhost"  appBase="webapps"
          unpackWARs="true" autoDeploy="true">
      <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
             prefix="localhost_access_log" suffix=".txt"
             pattern="%h %l %u %t &quot;%r&quot; %s %b" />
    </Host>
  </Engine>
</Service>
 
<Service name="Catalina2">
  <!-- Project 2 on port 8081 -->
  <Connector port="8081" protocol="HTTP/1.1"
             connectionTimeout="20000"
             redirectPort="8443" />
  <Engine name="Catalina2" defaultHost="localhost">
    <Realm className="org.apache.catalina.realm.LockOutRealm">
      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
             resourceName="UserDatabase"/>
    </Realm>
    <Host name="localhost"  appBase="project2_webapps"
          unpackWARs="true" autoDeploy="true">
      <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
             prefix="localhost_access_log" suffix=".txt"
             pattern="%h %l %u %t &quot;%r&quot; %s %b" />
    </Host>
  </Engine>
</Service>

确保防火墙设置允许8080和8081端口的流量：




sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --permanent --add-port=8081/tcp
sudo firewall-cmd --reload

现在，你可以将两个项目的WAR文件分别放入\`project1\_web

Spring Boot 中的 @Controller 注解：原理、用法与示例

2024-09-04

@Controller是Spring MVC框架中的一个注解，用于指示特定类作为控制器，该类负责处理来自用户的web请求。在Spring Boot中，@Controller注解通常与@RequestMapping注解一起使用，后者用来映射请求的URL。

使用方法：

在类的上一行使用@Controller注解。
在方法上使用@RequestMapping或其特化的注解（如@GetMapping、@PostMapping等）来指定请求的URL和HTTP方法。

例子代码：




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("/greetings")
public class GreetingController {
 
    @GetMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello, World!";
    }
}

在这个例子中，GreetingController类被标记为@Controller，表示它是一个控制器。@RequestMapping("/greetings")指定了该控制器处理的URL路径。hello()方法用@GetMapping("/hello")指出了具体的请求方式和路径，并用@ResponseBody注解指示返回的字符串直接作为HTTP响应的body内容。当访问/greetings/hello时，会收到文本"Hello, World!"的响应。

spring cloud项目微服务间互相调用使用自定义标注进行鉴权方案

2024-09-04

在Spring Cloud项目中，微服务间通常使用Feign客户端进行互相调用。鉴权方案可以通过自定义注解来实现。以下是一个简化的例子：

创建一个自定义的Feign鉴权注解：




@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomFeignAuth {
    // 可以添加属性定义鉴权方式等信息
}

实现一个Feign的拦截器，用于在请求中添加鉴权信息：




public class CustomFeignAuthInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        // 添加鉴权信息，例如Token
        template.header("Authorization", "Bearer " + getAccessToken());
    }
 
    private String getAccessToken() {
        // 获取Token的逻辑
        return "your_access_token";
    }
}

创建一个Feign的配置类，用于注册自定义的拦截器：




@Configuration
public class FeignConfig {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return new CustomFeignAuthInterceptor();
    }
}

在Feign客户端接口中使用自定义注解：




@FeignClient(name = "service-provider", configuration = FeignConfig.class)
public interface ServiceProviderClient {
 
    @CustomFeignAuth
    @GetMapping("/api/data")
    String getData();
}

在这个例子中，CustomFeignAuthInterceptor会在每个Feign请求被创建时被调用，并且在请求头中添加鉴权信息。@CustomFeignAuth注解可以用于标注哪些方法需要进行鉴权。

确保你的Feign客户端配置类包含了@EnableFeignClients注解，以便于Spring能够扫描并注册Feign客户端。

SpringBoot3里的文件上传

2024-09-04

在Spring Boot 3中，你可以使用Spring的@RestController和MultipartFile来实现文件上传的功能。以下是一个简单的例子：

首先，添加依赖到你的pom.xml：




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

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




import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
 
@RestController
public class FileUploadController {
 
    @PostMapping("/upload")
    public ResponseEntity<String> handleFileUpload(@RequestParam("file") MultipartFile file) {
        String originalFilename = file.getOriginalFilename();
        // 在这里添加你的文件上传逻辑，例如保存文件到磁盘或数据库
        // 保存文件到磁盘的示例代码
        // File savedFile = new File("upload-dir/" + originalFilename);
        // file.transferTo(savedFile);
 
        return ResponseEntity.ok("File uploaded successfully: " + originalFilename);
    }
}

确保你的应用程序有一个配置好的文件上传限制，例如在application.properties中设置：




spring.servlet.multipart.max-file-size=128KB
spring.servlet.multipart.max-request-size=128KB

这个配置限制了单个文件的大小和请求的总大小。根据你的需求，你可以调整这些值。

最后，确保你的Spring Boot应用程序有一个有效的@SpringBootApplication注解，它会启动Spring MVC和基于Spring的服务。

使用上述代码，你可以通过向/upload端点发送POST请求来上传文件。请求应该包含一个名为file的表单数据部分，其中包含你想上传的文件。

2024-09-04

报错信息 "openFile(/data/applogs/xxl-job/xxl-job-admin.log,true) call failed" 表示尝试打开位于路径 /data/applogs/xxl-job/xxl-job-admin.log 的文件时失败了。

解释：

这个错误通常发生在尝试访问或打开一个文件时，但由于某种原因操作没有成功。可能的原因包括：

文件不存在。
文件路径错误或不可访问。
文件权限不足，当前用户没有足够的权限去读取或写入文件。
文件系统错误或磁盘问题。
程序中的代码错误，如文件路径拼写错误。

解决方法：

确认文件存在：检查文件 /data/applogs/xxl-job/xxl-job-admin.log 是否存在。
检查路径：确保提供的路径是正确的，并且没有拼写错误。
权限问题：检查当前用户是否有足够的权限去读取或写入该文件。如果没有，使用 chmod (改变文件权限) 或 chown (改变文件所有者) 命令来修改权限或所有权。
文件系统和磁盘：检查文件系统是否有错误，运行磁盘检查工具（如 fsck）来修复可能存在的问题。
代码检查：如果是代码问题，检查代码中的文件路径是否正确拼写并且符合运行环境的路径规则。

在解决问题时，可以从最有可能的原因开始排查，直至找到问题的根源并解决。

（day two）基于Gateway网关拦截器和Redis实现单点登录和认证

2024-09-04




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
@Configuration
public class GatewayConfig {
 
    @Bean
    public GatewayFilter loginFilter() {
        return ((exchange, chain) -> {
            // 检查Redis中是否存在用户的Token
            String token = exchange.getRequest().getHeaders().getFirst("Token");
            StringRedisTemplate redisTemplate = connectionFactory.getStringRedisTemplate();
            Boolean hasKey = redisTemplate.hasKey(token);
 
            if (hasKey != null && hasKey) {
                // Token存在，继续请求
                return chain.filter(exchange);
            } else {
                // Token不存在，返回未授权的响应
                return ServerResponse.status(HttpStatus.UNAUTHORIZED)
                        .body(Mono.just("Token is invalid or not found"), String.class);
            }
        });
    }
 
    // 注意：以下代码省略了RedisConnectionFactory的定义和注入，请自行添加
    // @Autowired
    // private RedisConnectionFactory connectionFactory;
}

这个代码实例展示了如何在Spring Cloud Gateway中使用自定义的GatewayFilter来实现单点登录和验证。它通过检查请求中的Token是否存在于Redis数据库中，来判断用户是否已经登录。如果Token有效，则允许请求继续；如果无效或不存在，则返回未授权的响应。这个例子省略了RedisConnectionFactory的定义和注入，请根据实际情况自行添加。

# Spring Cloud Alibaba Nacos_配置中心与服务发现

2024-09-04

在Spring Cloud Alibaba中使用Nacos作为配置中心和服务发现组件，你需要做以下几步：

引入Spring Cloud Alibaba Nacos的依赖。
在application.properties或application.yml中配置Nacos服务器地址和应用名。
使用@Value注解或@ConfigurationProperties注解来获取配置。
使用@EnableDiscoveryClient注解开启服务发现。

以下是一个简单的示例：

pom.xml中添加依赖：




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

application.properties配置：




spring.application.name=nacos-example
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

Java代码示例：




import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableDiscoveryClient
public class NacosConfig {
 
    @Value("${my.config}")
    private String myConfig;
 
    public void outputConfig() {
        System.out.println("Config from Nacos: " + myConfig);
    }
}

在这个例子中，我们创建了一个简单的配置类NacosConfig，使用@EnableDiscoveryClient注解来开启服务发现，并使用@Value注解注入了名为my.config的配置。

确保你的Nacos服务器正在运行，并且配置数据已经发布到Nacos。当应用启动时，它会从Nacos拉取配置并注册到服务中心。

Spring Cloud Gateway网关聚合Knife4j4.0+

2024-09-04

在Spring Cloud Gateway中使用Knife4j 4.0+进行接口文档的聚合展示，你需要做以下几步：

在Spring Cloud Gateway中配置一个路由，将对Knife4j的请求代理到具体的Knife4j服务。
在Knife4j服务的application.yml或application.properties中配置Knife4j的基本信息，并确保开启Knife4j的Swagger集成。
在Knife4j服务的Swagger配置中指定Swagger的扫描路径。
如果有多个Knife4j实例，可以考虑使用Swagger的additional-springfox-docs属性进行文档的聚合。

以下是一个简化的示例：

application.yml配置（Knife4j服务）:




spring:
  application:
    name: knife4j-service
server:
  port: 8081
 
knife4j:
  enable: true
 
springfox:
  documentation:
    swagger:
      v2:
        path: /v2/api-docs
        enabled: true

Spring Cloud Gateway配置:




@Configuration
public class GatewayConfig {
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("knife4j", r -> r.path("/knife4j/**")
                        .filters(f -> f.rewritePath("/knife4j/(?<path>.*)", "/${path}"))
                        .uri("http://127.0.0.1:8081")) // 假设Knife4j服务地址
                .build();
    }
}

确保你的Knife4j服务开启了Swagger集成，并且所有需要被文档化的服务都配置了正确的Swagger扫描路径。如果有多个Knife4j服务实例，你可以在Gateway中配置多个路由，并在Swagger UI界面中手动配置additional-springfox-docs属性来指定其他服务的文档地址。

以上代码仅为示例，实际配置可能需要根据你的具体环境进行调整。

Spring 原理

2024-09-04

Spring 是一个开源的容器式的轻量级Java开发框架，它解决了企业应用开发的复杂性。Spring的核心是控制反转（IoC）和面向切面编程（AOP）。

控制反转（IoC）：Spring通过控制反转实现了松耦合。对象不会自己去查找依赖的对象，而是由Spring容器来注入依赖的对象。

面向切面编程（AOP）：Spring提供了面向切面编程的功能，可以让你在不修改原始代码的情况下增加新的功能。

Spring框架的主要特性：

依赖注入（DI）
面向切面编程（AOP）
容器
MVC框架
事务管理
数据库访问

Spring框架的七大模块：

Core Container（核心容器）
Data Access/Integration（数据访问/集成）
Web
AOP（面向切面编程）
Instrumentation（工具）
Messaging（消息传递）
Test（测试）

Spring原理示意图：

Spring原理图

Spring框架的核心组件：

BeanFactory：是工厂模式的实现，是Spring的基本容器。
ApplicationContext：是BeanFactory的子接口，提供了更多的功能，例如国际化支持和环境抽象。
Core Container（核心容器）：由spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring表达式语言）模块组成，提供了框架的基础功能。
Spring AOP：提供了面向切面编程的实现。
Data Access/Integration：包括JDBC，ORM，OXM，JMS和Transaction模块。
Web：提供了基于Servlet的Spring MVC和WebSocket的实现。

以上是Spring框架的基本概述和关键特性，具体实现和应用需要结合具体的设计模式和开发实践。

RabbitMq几种工作模式详细讲解

2024-09-04

RabbitMQ是一个消息代理，它接收和转发消息。RabbitMQ支持多种消息传递模式，包括简单的队列模式、工作队列模式、发布/订阅模式、路由模式、通配符模式等。

简单队列模式（Simple Queue）

简单的队列模式是最基本的消息队列模式，一个生产者发送消息到队列，一个消费者从队列中取消息。

生产者代码示例：




import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
 
channel.queue_declare(queue='hello')
 
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")
 
connection.close()

消费者代码示例：




import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
 
channel.queue_declare(queue='hello')
 
def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
 
channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)
 
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

工作队列模式（Work Queue）

工作队列模式是多个消费者平分任务，每个消费者处理的任务是均衡的。




import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
 
channel.queue_declare(queue='task_queue', durable=True)
 
message = 'Hello World!'
channel.basic_publish(exchange='',
                      routing_key='task_queue',
                      body=message,
                      properties=pika.BasicProperties(
                          delivery_mode=2,  # make message persistent
                      ))
print(f" [x] Sent {message}")
 
connection.close()




import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
 
channel.queue_declare(queue='task_queue', durable=True)
 
def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
 
channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='task_queue', on_message_callback=callback)
 
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

发布/订阅模式（Publish/Subscribe）

发布/订阅模式是生产者发送消息到交换机，交换机根据规则将消息发送到多个队列。




import pika
 
conne