Tech Blog

2024-09-04

要收集Kubernetes集群中以Tomcat运行的应用日志，可以使用以下方法：

使用kubectl logs命令直接从Pod获取日志：




kubectl logs <pod-name> -n <namespace>

使用stdout输出，配置Tomcat以将日志输出到容器的标准输出。
使用sidecar容器模式，其中一个容器负责运行Tomcat应用，另一个容器负责收集日志。
使用ELK（Elasticsearch, Logstash, Kibana）堆栈进行集中日志管理。

以下是一个使用sidecar容器收集日志的示例。

首先，创建一个sidecar容器的配置，它将监控主容器的日志文件并将其转发到ELK或其他日志收集系统。




apiVersion: v1
kind: Pod
metadata:
  name: tomcat-sidecar-logs
  labels:
    app: tomcat
spec:
  containers:
  - name: tomcat
    image: tomcat:latest
    ports:
    - containerPort: 8080
  - name: log-collector
    image: googlecontainer/fluentd-gcp:latest
    env:
    - name: FLUENTD_ARGS
      value: -c /etc/fluentd-config.properties
    volumeMounts:
    - name: tomcat-logs
      mountPath: /var/log/tomcat
    - name: fluentd-config-volume
      mountPath: /etc/fluentd-config.properties
      subPath: fluentd-config.properties
    resources:
      limits:
        memory: 200Mi
        cpu: 100m
  volumes:
  - name: fluentd-config-volume
    configMap:
      name: fluentd-config
  - name: tomcat-logs
    emptyDir: {}

然后，创建一个ConfigMap来存储fluentd配置：




apiVersion: v1
kind: ConfigMap
metadata:
  name: fluentd-config
data:
  fluentd-config.properties: |
    <source>
      @type tail
      path /var/log/tomcat/*.log
      pos_file /var/log/tomcat/tomcat.log.pos
      tag tomcat.log
      format none
    </source>
    <match tomcat.log>
      @type google_cloud
      buffer_type file
      buffer_path /var/log/fluentd-buffers/tomcat.log
      num_threads 1
    </match>

这个配置定义了一个Pod，其中包含一个Tomcat容器和一个fluentd容器。fluentd容器负责收集Tomcat日志文件并将其转发到Google Cloud日志系统。你可以根据自己的日志收集需求和云服务进行相应的调整。

- 阅读更多 -

Spring Cloud学习【统一网关 Gateway】

System

2024-09-04

所有,java

在Spring Cloud中，Spring Cloud Gateway是一种提供统一路由方式的网关，它构建于Spring Framework 5，Project Reactor和Spring Boot 2.0之上，使用非阻塞回调式的API。

以下是一个简单的Spring Cloud Gateway的示例配置，它将会路由到一个名为service-provider的服务。

在pom.xml中添加依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!-- 如果你需要Gateway的动态路由能力，还需要添加下面的依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Finchley.SR2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

配置application.yml：




spring:
  cloud:
    gateway:
      routes:
        - id: service_route
          uri: http://localhost:8080
          predicates:
            - Path=/service-provider/**
          filters:
            - StripPrefix=1

在这个配置中，我们定义了一个路由，该路由将所有到达/service-provider/的请求都转发到http://localhost:8080。StripPrefix=1表示在转发请求之前去掉第一层路径。

启动类：




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

启动Gateway服务后，所有到达Gateway服务的/service-provider/的请求都会被转发到http://localhost:8080。这是Spring Cloud Gateway的一个基本使用示例。

- 阅读更多 -

用前端框架Bootstrap和Django实现用户注册页面

System

2024-09-04

所有,数据库

以下是一个使用Bootstrap和Django实现用户注册页面的简单示例。这个示例仅包含必要的字段，实际应用中可能需要更多的字段和验证逻辑。

首先，在Django的views.py文件中创建一个视图：




from django.shortcuts import render
from django.contrib.auth.forms import UserCreationForm
 
def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('login')  # Redirect to the login page.
    else:
        form = UserCreationForm()
    return render(request, 'register.html', {'form': form})

然后，在Django的urls.py文件中添加路径：




from django.urls import path
from .views import register
 
urlpatterns = [
    # ...
    path('register/', register, name='register'),
]

接下来，创建一个名为register.html的HTML模板并使用Bootstrap：




{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册页面</title>
    <link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
</head>
<body>
    <div class="container">
        <div class="row justify-content-center mt-5">
            <div class="col-md-6">
                <div class="card">
                    <h5 class="card-header">用户注册</h5>
                    <div class="card-body">
                        <form method="post" action="{% url 'register' %}">
                            {% csrf_token %}
                            {{ form.as_p }}
                            <button type="submit" class="btn btn-primary">注册</button>
                        </form>
                    </div>
                </div>
            </div>
        </div>
    </div>
    <script src="{% static 'js/bootstrap.bundle.min.js' %}"></script>
</body>
</html>

确保你已经在Django的settings.py中配置了STATICFILES\_DIRS和STATIC\_URL，并且有相应的bootstrap.min.css和bootstrap.bundle.min.js文件在你的静态文件夹中。

这个示例提供了一个简单的用户注册页面，并使用了Django的内置UserCreationForm来处理用户输入。在实际应用中，你可能需要添加更多的字段，以及进行更复杂的验证和错误处理。

- 阅读更多 -

springboot3搭建WebSocket服务

System

2024-09-04

所有,java

在Spring Boot 3中搭建WebSocket服务，你可以使用Spring的WebSocket支持。以下是一个简单的例子，展示了如何配置和创建一个简单的WebSocket端点。

添加依赖到你的pom.xml：




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

配置WebSocket：




import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

创建WebSocket端点：




import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
 
@Controller
public class WebSocketController {
 
    // 如果是Java版本低于1.9，需要添加此Bean，用于支持WebSocket
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
 
    @GetMapping("/sendMessage")
    @ResponseBody
    public String sendMessage() {
        // 调用WebSocket方法发送消息
        // 示例中省略具体发送逻辑
        return "Message sent";
    }
}

创建WebSocket服务端点：




import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
 
@Component
@ServerEndpoint("/ws")
public class WebSocketServer {
 
    private static final CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<>();
 
    priv

System

2024-09-04

所有,java

Seata 提供了四种不同的分布式事务模式，分别是AT 模式、TCC 模式、SAGA 模式和XA 模式。

AT 模式（Automatic Transaction）自动事务模式是 Seata 的默认模式，它使用了一个全局事务来管理整个微服务架构内的所有本地事务。AT 模式通过对业务代码零侵入，实现了对本地事务的管理。
TCC 模式（Try-Confirm-Cancel）是一种较为传统的分布式事务解决方案，它需要用户自己实现 try、confirm 和 cancel 三个操作。TCC 模式对业务代码有较高的侵入性。
SAGA 模式是一种复杂的事务模式，它将整个事务分解为多个本地事务，并通过 Saga 事务管理器来协调这些本地事务的执行。SAGA 模式对业务代码有较高的侵入性，且实现较为复杂。
XA 模式是 Seata 对传统 XA 分布式事务的支持，它通过数据库的 XA 接口来管理分布式事务，但是它需要数据库支持 XA 事务，且性能不如 AT 模式。

以下是 AT 模式的简单示例：




@GlobalTransactional
public void doBusiness() {
    // 调用微服务A的本地事务
    microserviceA.prepareBusiness();
    // 调用微服务B的本地事务
    microserviceB.prepareBusiness();
    // 如果微服务A和微服务B的本地事务都成功，全局事务会提交，否则会回滚
}

在这个例子中，@GlobalTransactional 注解被用来标记一个方法，该方法包含了对多个本地事务的调用。Seata 会自动管理这些本地事务，保证它们作为一个整体要么全提交，要么全回滚。这就是 AT 模式的核心思想：通过有限制的方式对业务代码进行改造，使其能够参与到全局事务中。

- 阅读更多 -

ORACLE EBS供应商信息表（含银行信息）

System

2024-09-04

所有,数据库

在Oracle E-Business Suite (EBS) 中，供应商的银行信息通常存储在不同的表中，这取决于具体的应用程序模块。例如，供应商的银行信息可能存储在以下几个表中：

VENDOR_BANK_USE_ALL：包含供应商银行账号的使用信息。
VEND_BANK_ACCOUNT_ALL：包含供应商银行账号的详细信息。
VEND_BANK_ACCOUNT_SITES_ALL：包含供应商银行账号的站点特定信息。
VEND_BANK_ACCOUNT_SITES_V：包含这些记录的数值列版本。

以下是一个简单的SQL查询，用于从这些表中提取供应商的银行信息：




SELECT vb.vendor_id, vb.bank_account_name, vb.bank_account_number, 
       vb.bank_name, vb.currency_code, vb.status, 
       vbs.site_id, vbs.bank_account_site_name, vbs.status
FROM VEND_BANK_ACCOUNT_ALL vb
JOIN VEND_BANK_ACCOUNT_SITES_ALL vbs ON vb.bank_account_id = vbs.bank_account_id
WHERE vb.vendor_id = :vendor_id;

这个查询展示了如何连接这两个表来获取特定供应商的银行账号信息。:vendor_id 是一个绑定变量，你需要在执行查询时提供供应商的ID。

请注意，具体的表名和列名可能会根据EBS系统的版本和配置有所不同。如果你需要查询特定的数据库视图或表，你可能需要查看EBS的数据字典或联系你的数据库管理员。

- 阅读更多 -

electron 嵌入java应用，并且嵌入redis,mysql,打包

System

2024-09-04

所有,redis

要在Electron应用中嵌入Java应用，并且嵌入Redis、MySQL，你需要按以下步骤操作：

安装Electron和Java运行时环境（JRE或JDK）。
使用Electron的BrowserWindow加载你的Java应用。
对于Redis和MySQL，你可以使用Node.js的客户端库，如ioredis和mysql。
将依赖库通过Electron的package.json文件配置，在打包时将其包含进去。

以下是一个简单的示例：




// main.js
const { app, BrowserWindow } = require('electron');
const path = require('path');
const url = require('url');
 
let win;
 
function createWindow() {
  // 创建浏览器窗口
  win = new BrowserWindow({ width: 800, height: 600 });
 
  // 加载Java应用（这里需要你有一个Java应用的入口，例如JFrame）
  win.loadURL('jar:file://' + path.resolve(__dirname, 'YourJavaApp.jar') + '!/');
 
  // 其他配置...
}
 
app.on('ready', createWindow);
 
// 其他Electron事件处理...

对于Redis和MySQL，你可以使用Node.js客户端连接它们：




// redisClient.js
const Redis = require('ioredis');
const redis = new Redis();
 
// 使用redis.connect()等API与Redis进行交互
 
// mysqlClient.js
const mysql = require('mysql');
const connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'me',
  password : 'secret',
  database : 'my_db'
});
 
connection.connect();
// 使用connection.query()等API与MySQL进行交互

最后，在package.json中配置你的Electron应用依赖：




{
  "name": "your-electron-app",
  "version": "1.0.0",
  "main": "main.js",
  "dependencies": {
    "electron": "^10.1.2",
    "ioredis": "^4.1.3",
    "mysql": "^2.18.1"
    // 其他依赖...
  },
  "devDependencies": {
    // 开发依赖...
  }
}

对于打包，你可以使用Electron的打包工具，如electron-packager或electron-builder。




# 使用electron-packager
./node_modules/.bin/electron-packager . YourAppName --platform=win32 --arch=x64
 
# 使用electron-builder
npm install electron-builder --save-dev
npx electron-builder

确保在打包之前将所有依赖项正确安装到你的项目中。

- 阅读更多 -

Python3 httpserver — 实现 Web 服务器的基础类

System

2024-09-04

所有,python




import http.server
import socketserver
 
class SimpleHTTPRequestHandlerWithDirectory(http.server.SimpleHTTPRequestHandler):
    """
    自定义的请求处理类，用于重写默认的路径处理逻辑。
    """
    def translate_path(self, path):
        # 重写路径转换方法，使其可以指定一个目录
        # 这里的getattr是为了从SimpleHTTPRequestHandlerWithDirectory类或其父类中获取指定的目录属性
        self.directory = getattr(self, 'directory', '/your/custom/directory/path')
        path = self.directory + path
        return http.server.SimpleHTTPRequestHandler.translate_path(self, path)
 
if __name__ == '__main__':
    # 设置服务器根目录
    handler_class = SimpleHTTPRequestHandlerWithDirectory
    handler_class.directory = '/your/custom/directory/path'
 
    # 设置服务器的IP地址和端口
    port = 8000
    httpd = socketserver.TCPServer(("", port), handler_class)
 
    # 启动服务器
    print(f"Serving at port {port}...")
    httpd.serve_forever()

这段代码定义了一个继承自http.server.SimpleHTTPRequestHandler的类SimpleHTTPRequestHandlerWithDirectory，并重写了translate_path方法，以便能够指定服务器的根目录。在__main__块中，我们设置了服务器的IP地址和端口，并指定了自定义的处理类，然后启动了HTTP服务器。这个例子展示了如何使用Python标准库中的http.server模块来快速搭建一个具有特定根目录的HTTP服务器。

- 阅读更多 -

Oracle 创建定时任务

System

2024-09-04

所有,数据库

在Oracle中，创建一个定时任务通常使用DBMS\_SCHEDULER或DBMS\_JOB包。以下是使用DBMS\_SCHEDULER的一个例子：




BEGIN
  -- 创建一个定时任务
  DBMS_SCHEDULER.create_job (
    job_name        => 'my_sample_job',  -- 任务名称
    job_type        => 'PLSQL_BLOCK',    -- 任务类型，这里是PL/SQL代码块
    job_action      => 'BEGIN NULL; END;', -- 要执行的PL/SQL代码
    start_date      => SYSTIMESTAMP,     -- 任务开始时间
    repeat_interval => 'FREQ=DAILY; BYHOUR=2', -- 任务重复间隔，例如每天2点执行
    enabled         => TRUE,             -- 启用任务
    comments        => 'Daily job at 2 AM'); -- 任务描述
END;
/

确保在运行上述代码之前，你有足够的权限来创建作业，否则你可能需要联系你的数据库管理员来执行这个任务。

如果你使用的是旧版本的Oracle，可能需要使用DBMS\_JOB包来创建定时任务，但从Oracle 10g起，推荐使用DBMS\_SCHEDULER，因为它提供了更多的功能和灵活性。

- 阅读更多 -

DM和Oracle锁对比和分析

System

2024-09-04

所有,数据库

在分析DM（Dameng）数据库和Oracle数据库的锁机制对比时，可以从以下几个方面进行：

锁的粒度：不同的数据库可能支持不同粒度的锁，比如行级锁、表级锁等。
锁的类型：包括排它锁（X锁），共享锁（S锁），意向锁等。
锁的兼容性：不同类型的锁之间是否兼容。
死锁检测和解决：两个数据库是否有相同的死锁检测和解决机制。
锁的锁定粒度：某些数据库可能支持更细粒度的锁定，例如只锁定行中的某些列。
锁的持续时间：锁是否在事务结束时自动释放，或者是显式释放。
锁的语法和使用：包括锁的声明、获取和释放方式是否相同。

以下是一个简单的例子，比较在获取行锁时，DM和Oracle的语法差异：

DM 数据库获取行锁的示例：




BEGIN
    LOCK TABLE table_name IN ROW EXCLUSIVE MODE NOWAIT;
END;

Oracle 数据库获取行锁的示例：




LOCK TABLE table_name IN ROW EXCLUSIVE MODE NOWAIT;

在分析过程中，你可以注意到这些语法差异，并考虑这些差异如何影响应用程序的开发和维护。

- 阅读更多 -