分类后端技术下的文章

2024-09-04

在PostgreSQL中，创建表时可以指定自动生成的主键。通常，可以使用UUID、序列（SEQUENCE）或标识列（IDENTITY）来作为主键。

使用UUID：




CREATE TABLE example_table (
    id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    name TEXT NOT NULL
);

在这个例子中，uuid_generate_v4()是PostgreSQL的一个扩展函数，它用于生成一个版本4的UUID。

使用序列：




CREATE SEQUENCE seq_example_table_id START 1;
 
CREATE TABLE example_table (
    id INTEGER PRIMARY KEY DEFAULT nextval('seq_example_table_id'),
    name TEXT NOT NULL
);

在这个例子中，我们首先创建了一个序列seq_example_table_id，然后在创建表时使用nextval函数来生成自增的主键。

使用标识列：




CREATE TABLE example_table (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

在这个例子中，我们使用了SQL标准的SERIAL关键字，它在背后使用序列来生成自增的ID。

System

2024-09-04

所有,数据库

在Ubuntu中，可以使用update-alternatives工具来管理系统默认的Python版本。以下是如何更换默认Python版本的步骤：

确保你已经安装了需要切换到的Python版本。
运行以下命令来配置update-alternatives：




sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.x 1

将python3.x替换为你想要设置为默认的Python版本，例如python3.6或python3.8。数字1是优先级，如果有多个Python版本，可以通过调整这个数字来决定默认使用哪个版本。

使用以下命令来配置默认的Python版本：




sudo update-alternatives --config python3

这个命令会列出所有配置过的Python版本，让你可以选择哪一个作为默认。

选择你想要的Python版本，update-alternatives会自动处理链接更改。

例如，如果你有Python 3.6和Python 3.8安装，你可以这样设置：




sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.6 1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.8 2
sudo update-alternatives --config python3

然后在提示时选择Python 3.8作为默认版本。

- 阅读更多 -

Springboot依赖注入Bean的三种方式，final+构造器注入Bean

System

2024-09-04

所有,java

SpringBoot依赖注入Bean的三种方式：

使用@Autowired注解自动注入：




@Autowired
private YourBean yourBean;

使用@Inject注解（需要Java CDI）：




@Inject
private YourBean yourBean;

构造方法注入：




private final YourBean yourBean;
 
@Autowired
public YourClass(YourBean yourBean) {
    this.yourBean = yourBean;
}

对于final字段和构造器结合的方式，Spring会在构造器执行后将final字段初始化，从而确保YourBean无法被更改，保证了注入的Bean不会被意外修改。

- 阅读更多 -

Python3 Unix 专属的服务

System

2024-09-04

所有,python

在Python中，如果您想要创建一个类似于Unix系统中的服务（即守护进程），您可以使用subprocess模块来执行必要的命令，并使用os模块来创建子进程。以下是一个简单的Python守护进程示例：




import subprocess
import os
import sys
 
def start_daemon(stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
    # 创建子进程，在后台运行
    try:
        pid = os.fork()
        if pid > 0:
            sys.exit(0)    # 父进程退出
    except OSError as e:
        print('Fork failed: %d (%s)' % (e.errno, e.strerror))
        sys.exit(1)
 
    os.chdir('/')    # 更改工作目录为根目录
    os.setsid()      # 创建一个新的会话，使当前进程成为新会话的领导进程
    os.umask(0)      # 重设文件模式创建掩码
 
    try:
        pid = os.fork()
        if pid > 0:
            sys.exit(0)    # 第二个子进程退出
    except OSError as e:
        print('Fork failed: %d (%s)' % (e.errno, e.strerror))
        sys.exit(1)
 
    # 重定向标准输入输出到/dev/null
    with open(stdin, 'r') as read_null, \
         open(stdout, 'a+') as write_null, \
         open(stderr, 'a+') as err_null:
 
        os.dup2(read_null.fileno(), sys.stdin.fileno())
        os.dup2(write_null.fileno(), sys.stdout.fileno())
        os.dup2(err_null.fileno(), sys.stderr.fileno())
 
        # 在这里执行您的守护进程逻辑
        # 例如，启动一个长时间运行的HTTP服务器
        subprocess.run(['python', '-m', 'http.server', '80'])
 
if __name__ == '__main__':
    start_daemon()

这段代码首先尝试创建一个子进程，然后再次创建一个，以确保该进程不是会话领导者，并且没有控制终端。标准输入、输出和错误都被重定向到/dev/null，以避免守护进程占用任何控制终端。在最后一个fork()之后，守护进程可以继续运行它的工作，例如启动一个HTTP服务器。

请注意，在生产环境中部署守护进程时，您还需要考虑如何处理异常和信号（如SIGTERM），以优雅地关闭服务。

- 阅读更多 -

Oracle SQL 性能分析原理与实战演练

System

2024-09-04

所有,数据库




-- 假设我们有一个名为"employees"的表，包含员工信息
-- 以下SQL语句展示了如何使用Oracle的EXPLAIN PLAN来分析一个查询语句的执行计划
 
-- 首先，我们需要为查询语句创建一个执行计划
EXPLAIN PLAN FOR
SELECT * FROM employees WHERE department_id = 10;
 
-- 然后，我们可以通过DBMS_XPLAN.DISPLAY来显示刚才创建的执行计划
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);
 
-- 这将输出查询的执行计划，包括每一步的成本、选择性、运行路径等信息
-- 分析执行计划可以帮助开发者识别潜在的性能瓶颈，并采取相应的优化措施

这个例子展示了如何在Oracle数据库中使用EXPLAIN PLAN来获取一个查询语句的执行计划，并通过DBMS\_XPLAN.DISPLAY函数来显示这个执行计划。执行计划包含了查询执行的详细步骤和成本估算，可以帮助开发者理解查询是如何被执行的，从而进行性能优化。

System

2024-09-04

所有,java

在CentOS 8上使用sdkman安装并配置Tomcat以部署Java Web项目的步骤如下：

安装sdkman：




curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

安装Java：




sdk install java

安装Tomcat：




sdk install tomcat

启动Tomcat服务：




tomcat start

将Java Web项目的WAR文件复制到Tomcat的部署目录下：




cp your-project.war /usr/local/tomcat/webapps/

访问你的Java Web项目：

打开浏览器并输入 http://<your-server-ip>:8080/your-project

注意：替换 <your-server-ip> 为你的服务器IP地址，your-project 为你的项目名。

以上步骤假设你已经有了一个编译好的WAR文件。如果你需要从源码构建项目，你可以先在本地开发环境构建WAR，然后按照上述步骤部署到Tomcat。

System

2024-09-04

所有,java




import org.springframework.statemachine.state.State;
import org.springframework.statemachine.transition.Transition;
 
// 定义订单状态
public enum OrderStates {
    NEW, PENDING, SHIPPED, DELIVERED
}
 
// 定义订单事件
public enum OrderEvents {
    PAY, SHIP, DELIVER
}
 
// 配置Spring StateMachine
@Configuration
@EnableStateMachine(name = "orderStateMachine")
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStates, OrderEvents> {
 
    @Override
    public void configure(StateMachineStateConfigurer<OrderStates, OrderEvents> states) throws Exception {
        states
            .withStates()
            .initial(OrderStates.NEW)
            .states(EnumSet.allOf(OrderStates.class));
    }
 
    @Override
    public void configure(StateMachineTransitionConfigurer<OrderStates, OrderEvents> transitions) throws Exception {
        transitions
            .withExternal()
            .source(OrderStates.NEW)
            .target(OrderStates.PENDING)
            .event(OrderEvents.PAY)
            .and()
            .withExternal()
            .source(OrderStates.PENDING)
            .target(OrderStates.SHIPPED)
            .event(OrderEvents.SHIP)
            .and()
            .withExternal()
            .source(OrderStates.SHIPPED)
            .target(OrderStates.DELIVERED)
            .event(OrderEvents.DELIVER);
    }
 
    @Bean
    public Action<OrderStates, OrderEvents> printAction() {
        return new Action<OrderStates, OrderEvents>() {
            @Override
            public void execute(StateContext<OrderStates, OrderEvents> context) {
                State<OrderStates, OrderEvents> state = context.getState();
                System.out.println("Current state is: " + state.getId());
            }
        };
    }
}
 
// 使用StateMachine
@Service
public class OrderStateService {
 
    @Autowired
    private StateMachine<OrderStates, OrderEvents> stateMachine;
 
    public void changeOrderState(OrderEvents event, Order order) {
        stateMachine.start();
        stateMachine.sendEvent(event);
        // 可以添加额外的逻辑来处理订单
    }
}

这个代码示例展示了如何在Spring Boot应用中使用Spring Statemachine来管理订单状态的流转。首先定义了订单的状态和事件，然后通过配置类配置状态机，并定义状态转换及其对应的动作。最后，在一个服务类中，我们可以通过发送事件来触发状态的改变。这个例子简单而直接，展示了如何将状态机引入到实际的业务流程中。

- 阅读更多 -

ORACLE EBS 销售订单发运全流程及API详解

System

2024-09-04

所有,数据库




-- 假设我们已经有了一个销售订单号为10000的销售订单
DECLARE
  v_return_status VARCHAR2(100);
  v_msg_count    NUMBER;
  v_msg_data     VARCHAR2(4000);
BEGIN
  -- 调用API进行发运处理
  fnd_global.apps_initialize(user_id => 123456,
                             resp_id => 123456,
                             resp_appl_id => 20000);
 
  -- 调用API函数处理销售订单发运
  mo_global.set_policy_context('S', '101'); -- 101为你的子模块编号
  mo_global.set_policy_context('O', '10000'); -- 10000为销售订单号
 
  -- 此处可以调用API函数进行发运处理，例如：
  -- mo_sales_order_pub.process_order_for_delivery(p_order_id => 10000,
  --                                               p_org_id   => 101,
  --                                               p_return_status => v_return_status,
  --                                               p_msg_count => v_msg_count,
  --                                               p_msg_data => v_msg_data);
 
  -- 这里的代码根据实际API函数进行调整
  -- 输出结果
  DBMS_OUTPUT.PUT_LINE('Return Status: ' || v_return_status);
  DBMS_OUTPUT.PUT_LINE('Message Count: ' || TO_CHAR(v_msg_count));
  DBMS_OUTPUT.PUT_LINE('Message Data: ' || v_msg_data);
END;

这段PL/SQL代码示例展示了如何在Oracle EBS环境中使用API来处理销售订单的发运。代码中使用了fnd_global.apps_initialize来初始化用户会话，mo_global.set_policy_context来设置策略上下文，然后调用了一个假设的API函数mo_sales_order_pub.process_order_for_delivery来处理订单发运。代码的输出显示了API调用的结果。这个例子教会开发者如何在Oracle EBS中使用API进行业务流程的自动化。

- 阅读更多 -

通过python操作redis（windows）

System

2024-09-04

所有,redis

在Windows上使用Python操作Redis，你需要安装Redis服务器并确保它正在运行，然后安装Python的Redis客户端，通常使用redis-py库。

安装Redis服务器：
- 下载Windows版本的Redis：https://github.com/MicrosoftArchive/redis/releases
- 解压缩并运行redis-server.exe启动Redis服务器。
安装redis-py客户端库：
```
pip install redis
```

使用Python操作Redis：




import redis
 
# 创建Redis连接对象，默认连接本地Redis实例，如果需要连接远程Redis服务，需要指定host和port
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 设置键值对
r.set('key', 'value')
 
# 获取键的值
value = r.get('key')
print(value)  # 输出b'value'，因为Redis返回的是字节字符串
 
# 其他操作，如列表操作、集合操作、散列操作等

确保Redis服务器在运行，并根据需要修改redis.Redis的参数以连接到正确的Redis实例。上面的代码提供了一个基本的操作Redis的例子。

- 阅读更多 -

MongoDB基础入门到深入多文档事务

System

2024-09-04

所有,数据库

在MongoDB中，多文档事务是从4.0版本开始引入的。在此之前，MongoDB使用$inc操作来处理原子计数器等操作，但这不是真正的多文档事务。

多文档事务必须在复制集或分片集群环境中的mongod实例上启用WiredTiger存储引擎来使用。

以下是一个多文档事务的示例代码：




from pymongo import MongoClient, ASCENDING
from pymongo.errors import PyMongoError
 
# 连接到MongoDB
client = MongoClient("mongodb://localhost:27017/")
db = client.test_database
collection = db.test_collection
 
# 确保MongoDB已启用事务
if db.command("listCommands")["startTransaction"]:
    print("事务支持已启用")
else:
    print("事务不支持")
    exit()
 
# 开始事务
session = client.start_session()
 
try:
    with session.start_transaction():
        # 执行多个操作
        collection.update_one({"x": 1}, {"$set": {"y": 1}}, session=session)
        collection.update_one({"x": 2}, {"$set": {"y": 2}}, session=session)
        collection.update_one({"x": 3}, {"$set": {"y": 3}}, session=session)
 
        # 提交事务
        session.commit_transaction()
except PyMongoError as e:
    # 如果有任何错误，回滚事务
    session.abort_transaction()
    print("事务失败：", e)
finally:
    # 结束会话
    session.end_session()

在这个例子中，我们首先检查MongoDB实例是否支持事务。然后，我们创建一个会话并开始一个事务。在事务块内，我们执行了三个更新操作。如果所有操作都成功，我们提交事务。如果在事务执行期间发生任何错误，我们将中止事务。最后，我们结束会话。

- 阅读更多 -