分类 java 下的文章

2024-09-01




import com.baomidou.mybatisplus.core.parser.ISqlParser;
import com.baomidou.mybatisplus.extension.handlers.AbstractSqlParserHandler;
import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor.TenantLineHandler;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.StringValue;
 
public class DataPermissionInterceptor extends TenantLineInnerInterceptor {
 
    @Override
    public Expression getTenantId() {
        // 假设当前用户的租户ID是"tenant1"
        return new StringValue("'tenant1'");
    }
 
    @Override
    public String getTenantIdColumn() {
        // 假设数据表中包含租户ID的字段名为tenant_id
        return "tenant_id";
    }
 
    @Override
    public boolean ignoreTable(String tableName) {
        // 忽略不需要租户筛选的表
        return "ignore_table".equals(tableName);
    }
 
    @Override
    public void beforeQuery(ISqlParser parser, TenantLineHandler tenantLineHandler, String sql, List<Object> parameters) {
        // 在SQL查询前执行的逻辑
    }
}

这个代码示例展示了如何扩展TenantLineInnerInterceptor类来实现租户行为，并重写了getTenantId和getTenantIdColumn方法以提供租户ID和租户ID字段名。还展示了如何使用ignoreTable方法来忽略不需要租户筛选的表。最后，beforeQuery方法可以用来在SQL查询前执行自定义逻辑。

System

2024-09-01

所有,java

在Tomcat中启用HTTPS，你需要进行以下步骤：

生成一个密钥库文件（Keystore）。
配置Tomcat的server.xml文件或者在context.xml中配置SSL连接器。
配置Web应用的web.xml以要求安全通信。

以下是一个简化的server.xml配置示例，展示了如何设置连接器以使用HTTPS：




<Connector port="8443" protocol="HTTP/1.1"
           SSLEnabled="true"
           keystoreFile="/path/to/your/keystore.jks"
           keystorePass="your_keystore_password"
           clientAuth="false"
           sslProtocol="TLS" />

port：指定HTTPS服务的端口号，默认为8443。
keystoreFile：指定密钥库文件的路径。
keystorePass：指定密钥库的密码。
clientAuth：设置为false以禁用双向SSL验证。如果你想要进行双向SSL验证，需要提供客户端证书。
sslProtocol：指定使用的SSL协议，默认为TLS。

确保你的Tomcat服务器有权访问指定的密钥库文件，并且密钥库文件是由可信的CA签发的服务器证书创建。

对于Web应用级别的安全配置，你可以在web.xml中添加一个security-constraint元素，要求所有请求都必须是安全的（即通过HTTPS接收）：




<security-constraint>
    <web-resource-collection>
        <web-resource-name>Secure Area</web-resource-name>
        <url-pattern>/*</url-pattern>
    </web-resource-collection>
    <user-data-constraint>
        <transport-guarantee>CONFIDENTIAL</transport-guarantee>
    </user-data-constraint>
</security-constraint>

url-pattern：指定哪些URL需要安全通信。
transport-guarantee：设置为CONFIDENTIAL以要求使用HTTPS。

请注意，这些配置可能需要根据你的实际部署环境进行调整。在实际操作中，你可能还需要考虑其他安全相关的配置，如SSL/TLS版本、加密算法的选择等。

- 阅读更多 -

JavaWeb开发笔记图解整理——XML、Tomcat、Servlet

System

2024-09-01

所有,java

在这个部分，我们将重点介绍XML、Tomcat服务器和Servlet的基本概念和使用。

XML：
XML是可扩展标记语言，主要用于数据存储和数据交换。在JavaWeb开发中，我们经常使用XML来配置web.xml文件，这是一个非常重要的配置文件。




<web-app>
    <servlet>
        <servlet-name>MyServlet</servlet-name>
        <servlet-class>com.example.MyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>MyServlet</servlet-name>
        <url-pattern>/do</url-pattern>
    </servlet-mapping>
</web-app>

Tomcat服务器：
Tomcat是一个开源的JavaWeb应用服务器，它也是Servlet和JSP的容器。在JavaWeb开发中，我们需要将我们的应用部署到Tomcat服务器上，然后启动服务器来运行我们的应用。




# 启动Tomcat
./catalina.sh start
 
# 关闭Tomcat
./catalina.sh stop

Servlet：
Servlet是用Java编写的服务器端程序，其主要用于交互式地浏览和修改数据，生成动态web页面内容。在JavaWeb开发中，我们需要编写Servlet来处理客户端的请求并响应。




import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
 
public class MyServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

这些是JavaWeb开发中的基本概念，对于学习JavaWeb开发的同学来说非常重要。在后续的篇章中，我们将会详细介绍这些技术的更深层次的应用和解决方案。

- 阅读更多 -

spring cloud 网关服务项目

System

2024-09-01

所有,java

Spring Cloud 网关服务通常使用 Spring Cloud Gateway 实现。以下是一个简单的 Spring Cloud Gateway 服务的示例：

在 pom.xml 中添加依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

在 application.yml 中配置路由和服务中心：




spring:
  cloud:
    gateway:
      routes:
        - id: service-route
          uri: lb://your-service
          predicates:
            - Path=/your-service/**
 
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

启动类添加 @EnableEurekaClient 注解：




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

这个简单的示例配置了一个路由，将 /your-service/** 下的请求路由到名为 your-service 的服务。同时，它也注册到了 Eureka 服务中心。这样就构建了一个基本的 Spring Cloud Gateway 服务。

- 阅读更多 -

ES: spring boot中使用ElasticsearchClient

System

2024-09-01

所有,java

在Spring Boot中使用ElasticsearchClient，你需要添加Spring Data Elasticsearch依赖，并配置Elasticsearch客户端。以下是一个基本的设置示例：

添加Spring Data Elasticsearch依赖到你的pom.xml文件中：




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
</dependencies>

在application.properties或application.yml中配置Elasticsearch的主机和端口：




# application.properties
spring.data.elasticsearch.cluster-name=your-cluster-name
spring.data.elasticsearch.cluster-nodes=localhost:9300

注入ElasticsearchClient到你的服务或组件中：




import org.elasticsearch.client.ElasticsearchClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class YourService {
 
    private final ElasticsearchClient elasticsearchClient;
 
    @Autowired
    public YourService(ElasticsearchClient elasticsearchClient) {
        this.elasticsearchClient = elasticsearchClient;
    }
 
    // 使用elasticsearchClient进行操作
}

使用ElasticsearchClient执行操作，例如索引文档、搜索文档：




public void indexDocument(String index, String id, Object document) {
    elasticsearchClient.prepareIndex(index, index, id)
        .setSource(document)
        .get();
}
 
public void searchDocuments(String index, String query) {
    SearchResponse response = elasticsearchClient.prepareSearch(index)
        .setQuery(queryStringQuery(query))
        .get();
    // 处理搜索结果
}

确保你的Elasticsearch服务器正在运行，并且配置的节点地址是可达的。以上代码提供了一个简单的示例，展示了如何在Spring Boot应用程序中注入和使用ElasticsearchClient。

System

2024-09-01

所有,java

Sentinel 是阿里巴巴提供的面向分布式服务架构的高可用流量控制组件。Sentinel 主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。

在Spring Cloud Alibaba中使用Sentinel，你需要做以下几步：

引入Sentinel依赖
配置Sentinel规则
使用注解或者编程方式使用Sentinel提供的资源保护功能

以下是一个使用Sentinel进行流量控制的简单示例：

在pom.xml中添加Sentinel依赖：




<dependencies>
    <!-- Sentinel 依赖 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
</dependencies>

在application.yml中配置Sentinel规则：




spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8080 # Sentinel 控制台地址
        port: 8719 # 默认端口，不需要可以不配置
      # 配置规则
      rules:
        - resource: /test
          limitApp: default
          grade: 1
          count: 5
          strategy: 0
          controlBehavior: 0

使用注解方式保护方法：




import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class TestController {
 
    @GetMapping("/test")
    @SentinelResource(value = "test", blockHandler = "handleException")
    public String test() {
        return "Test Sentinel";
    }
 
    public String handleException(BlockException ex) {
        return "Error: " + ex.getMessage();
    }
}

在这个例子中，我们定义了一个/test接口，并使用SentinelResource注解将其标记为Sentinel需要保护的资源。同时，我们定义了一个blockHandler方法，在资源访问受限时会调用该方法。

以上就是一个使用Sentinel进行简单流量控制的示例。在实际应用中，你可能需要根据具体需求进行更复杂的配置和编程。

- 阅读更多 -

Jackson 2.x 系列【31】Spring Boot 集成之字典回写

System

2024-09-01

所有,java




import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class JacksonConfig {
 
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        // 配置自动将字段转为下划线命名
        mapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        // 配置时间序列化和反序列化处理
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        mapper.registerModule(javaTimeModule);
        // 配置序列化时忽略空值字段
        mapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);
        // 其他配置...
        return mapper;
    }
}

这个配置类中定义了一个ObjectMapper的Bean，用于在Spring Boot项目中集成Jackson进行字段的下划线命名和时间的序列化。同时，配置了序列化时忽略空值字段的选项。这样，在Spring Boot应用中，Jackson的这些配置将会被应用，从而简化应用的配置并提高代码质量。

- 阅读更多 -

Spring Boot 热部署

System

2024-09-01

所有,java

Spring Boot 热部署，也被称为热替换（hot swapping）或者热加载（hot loading），是指在应用程序运行时更新代码和资源，而不需要重启应用程序。Spring Boot 支持热部署，但仅限于开发环境。

要在Spring Boot中启用热部署，请确保你的项目使用Spring Boot DevTools依赖。以下是如何在Maven项目中添加这个依赖的例子：




<dependencies>
    <!-- 添加 Spring Boot DevTools 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
</dependencies>

对于Gradle项目，添加以下依赖：




dependencies {
    // 添加 Spring Boot DevTools 依赖
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
}

确保你的开发环境支持热部署，例如，在IntelliJ IDEA中，你需要做如下设置：

打开Preferences/Settings > Build, Execution, Deployment > Compiler，勾选Build project automatically。
打开Preferences/Settings > Build, Execution, Deployment > Debugging，勾选Hot swap code/resources。

注意：在生产环境中不应启用热部署特性，因为它可能会带来安全风险和性能问题。仅在开发环境中使用。

- 阅读更多 -

Tomcat源码分析 ----- Tomcat 启动过程

System

2024-09-01

所有,java

在上一篇文章中，我们已经分析了Tomcat启动的前半部分，包括初始化和配置阶段。这一篇文章我们将继续分析Tomcat的启动过程，包括服务的创建和监听端口的绑定。

在上一篇文章的init方法中，我们看到了init方法最后调用了start方法。在start方法中，Tomcat会创建并启动各种服务，包括Catalina的Servlet容器和Connector，它们分别负责处理请求和响应。




public void start() throws LifecycleException {
    if (getServer() == null) {
        // ...
    }
 
    // 标记Server已经启动
    server.setAwait(true);
 
    // 启动Server
    server.start();
 
    // 如果Server不是等待模式，则直接返回
    if (!server.getAwait()) {
        return;
    }
 
    // 创建并启动ShutdownHook线程，用于监听关闭命令
    // ...
 
    // 在等待模式下等待关闭命令
    // ...
}

在Server的start方法中，会创建并启动Service，而Service会包含一个或多个Connector和一个Container。




public void start() throws LifecycleException {
    // 标记Service状态为启动中
    setState(LifecycleState.STARTING);
 
    // 启动所有的Connector
    for (Connector connector : findServices()) {
        try {
            connector.start();
        } catch (Exception e) {
            // ...
        }
    }
 
    // 启动Container
    if (container != null) {
        container.start();
    }
 
    // ...
 
    // 标记Service状态为已启动
    setState(LifecycleState.STARTED);
}

在Connector的start方法中，会创建并启动ACCEPTOR线程，这个线程会监听网络端口，一旦有请求到达，就会处理请求。




public void start() throws Exception {
    // 标记Connector状态为启动中
    setState(LifecycleState.STARTING);
 
    // 初始化并绑定端口
    initializeConnection();
 
    // 启动Poller线程，负责连接管理和请求处理
    poller.start();
 
    // 启动Acceptor线程，负责接受新的连接
    acceptor.start();
 
    // ...
 
    // 标记Connector状态为已启动
    setState(LifecycleState.STARTED);
}

在Acceptor的start方法中，会创建一个新的线程，并在这个线程中运行run方法，监听并接受新的连接。




public void start() throws Exception {
    // 如果Acceptor已经启动，则直接返回
    if (running) {
        return;
    }
 
    // 标记Acceptor状态为启动中
    running = true;
    paused = false;
 
    // 创建并启动一个新的线程，执行Acceptor的处理逻辑
    thread = new Thread(new Acceptor(), getName());
    thread.setPriority(threadPriority);
    thread.setDaemon(true);
    thread.start();
}

至此，Tomcat的启动过程已经分析完毕。在接下来的文章中，我们将分析Tomcat是如何处理接收到的连接和请求的。

System

2024-09-01

所有,java




# 使用官方tomcat镜像
FROM tomcat:9-jdk11
 
# 将应用打包的jar文件复制到tomcat容器中的指定位置
COPY target/my-application.war /usr/local/tomcat/webapps/
 
# 设置容器启动时执行的命令
CMD ["catalina.sh", "run"]

这个Dockerfile使用了官方的Tomcat镜像，并且复制了应用程序的WAR文件到Tomcat的webapps目录中。CMD指令设置了容器启动时执行的命令。这个例子展示了如何使用官方镜像并将自己的应用程序与之集成。

- 阅读更多 -