分类后端技术下的文章

SpringBoot集成Milo库实现OPC UA客户端：连接、遍历节点、读取、写入、订阅与批量订阅

2024-09-02




import org.eclipse.milo.opcua.sdk.client.*;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscription;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.StatusCode;
import org.eclipse.milo.opcua.stack.core.types.enumerated.ServerState;
import org.eclipse.milo.opcua.stack.core.types.structures.EndpointDescription;
 
import java.util.EnumSet;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
 
public class OpcUaClientExample {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建OPC UA客户端配置
        OpcUaClientConfig clientConfig = OpcUaClientConfig.builder()
                .setApplicationName(LocalizedText.english("OpcUaClient"))
                .setApplicationUri("http://example.com/OpcUaClient")
                .setProductUri("http://example.com/OpcUaClient")
                .build();
 
        // 连接到OPC UA服务器
        try (OpcUaClient client = OpcUaClient.create("opc.tcp://example.com:4840", clientConfig)) {
            // 连接
            client.connect().get();
 
            // 浏览服务器端点并选择一个端点
            EndpointDescription endpoint = client.getEndpoints()
                    .orElseThrow(() -> new IllegalStateException("No endpoints found"))
                    .stream()
                    .findFirst()
                    .orElseThrow(() -> new IllegalStateException("No endpoints found"));
 
            // 状态变更事件
            client.addStateListener((oldState, newState) -> {
                System.out.println("State changed from " + oldState + " to " + newState);
                if (newState == ServerState.Connected) {
                    System.out.println("Connected to server!");
                }
            });
 
            // 浏览服务器信息
            client.getServerDiagnosticInfos()
                    .ifPresent(diagnosticInfos -> diagnosticInfos.forEach(diagnosticInfo -> {
                        System.out.println("Server Diagnostic Info: " + diagnosticInfo);
                    }));
 
            // 创建订阅
            UaSubscription subscription = client.getSubscriptionManager().createSubscription().get();
 
            // 读取节点属性
            CompletableFuture<DataValue> future = client.readValue(0.0, NodeId.parse("ns=2;s=1"));
            DataValue value

- 阅读更多 -

Spring Cloud + Docker 构建微服务架构下的电商平台后台系统

System

2024-09-02

所有,java

以下是一个简化的代码示例，展示了如何使用Spring Cloud和Docker构建微服务架构的电商平台后端系统。




// 假设有一个服务注册与发现的组件，如Eureka或Consul
@EnableEurekaClient
@SpringBootApplication
public class CatalogServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(CatalogServiceApplication.class, args);
    }
}
 
@RestController
public class CatalogController {
    // 假设这里有API处理商品目录的逻辑
}
 
// Dockerfile示例
FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD target/catalog-service.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
 
// docker-compose.yml示例
version: '3'
services:
  catalog-service:
    build:
      context: ./CatalogService
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    networks:
      - net-ecs
  eureka-server:
    image: openjdk:8-jdk-alpine
    ports:
      - "8761:8761"
    networks:
      - net-ecs
    command: >
      java -jar spring-cloud-starter-netflix-eureka-server.jar
        --spring.profiles.active=native
        --spring.security.user.name=user
        --spring.security.user.password=pass
 
networks:
  net-ecs:
    driver: bridge

这个示例展示了如何构建一个服务提供者（CatalogService），并且如何使用Docker和docker-compose来部署它。服务使用Eureka进行服务注册与发现。这个示例假设你已经有了Spring Cloud和Docker的基础知识。

- 阅读更多 -

创建一个springCloud+nacos项目

System

2024-09-02

所有,java

创建一个Spring Cloud和Nacos的项目，你可以遵循以下步骤：

创建一个Spring Boot项目，并添加必要的依赖。
配置Spring Boot应用以使用Nacos作为服务发现和配置管理。
创建服务提供者和服务消费者。

以下是一个简单的例子：

步骤1： 创建一个Spring Boot项目。




mvn archetype:generate -DgroupId=com.example -DartifactId=nacos-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
cd nacos-demo

步骤2： 添加Spring Cloud和Nacos依赖。

在pom.xml中添加：




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>0.9.0.RELEASE</version>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>0.9.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

步骤3： 配置application.properties或application.yml以使用Nacos。




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

步骤4： 创建服务提供者。




@EnableDiscoveryClient
@SpringBootApplication
public class NacosProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(NacosProviderApplication.class, args);
    }
 
    @RestController
    public class EchoController {
        @GetMapping(value = "/echo/{string}")
        public String echo(@PathVariable String string) {
            return "Hello " + string;
        }
    }
}

步骤5： 创建服务消费者。




@EnableDiscoveryClient
@SpringBootApplication
public class NacosConsumerApplication {
    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
 
    public static void main(String[] args) {
        SpringApplication.run(NacosConsumerApplication.class, args);
    }
 
    @RestControl

- 阅读更多 -

Python从入门到快速精通模型算法：日志和调试工具栏

System

2024-09-02

所有,数据库




import streamlit as st
 
# 创建一个简单的日志记录函数
def log_message(message):
    st.balloons()
    st.write(f"Log: {message}")
 
# 创建一个简单的调试函数
def debug_mode(flag):
    if flag:
        st.write("Debug mode is on.")
 
# 检查是否处于调试模式并记录消息
debug_mode(True)
log_message("这是一个日志消息。")

这段代码演示了如何在Streamlit应用中创建简单的日志记录和调试工具。它定义了两个函数log_message和debug_mode，分别用于日志记录和调试模式的开启。然后，代码检查是否应该开启调试模式，并使用log_message函数记录一条日志消息。

- 阅读更多 -

SpringSecurity安全框架 ——认证与授权

System

2024-09-02

所有,java

在Spring Security中，认证（Authentication）和授权（Authorization）是两个核心的安全控制机制。

认证（Authentication）：

确认用户的身份。通常涉及到用户名和密码的验证。

授权（Authorization）：

确认用户是否有权限进行某项操作。

以下是一个简单的Spring Security配置示例，包括认证和授权：




import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}userPassword").roles("USER")
            .and()
            .withUser("admin").password("{noop}adminPassword").roles("USER", "ADMIN");
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/db/**").access("hasRole('ADMIN') and hasIpAddress('123.123.123.123')")
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
}

在这个配置中：

configure(AuthenticationManagerBuilder auth) 方法定义了内存中的用户和他们的角色。
configure(HttpSecurity http) 方法定义了请求的授权规则，例如哪些URL路径是公开的，哪些需要特定的角色或IP地址访问。

这个配置使用了Spring Security的表达式语言来定义权限，并且使用了表单登录。开发者可以根据实际情况调整认证和授权策略。

- 阅读更多 -

oracle查看数据库历史操作用户

System

2024-09-02

所有,数据库

在Oracle数据库中，可以通过查询数据字典视图DBA_AUDIT_TRAIL来查看数据库的历史操作记录。如果你有足够的权限，可以查看所有用户的历史操作；如果没有，你可能只能查看自己的操作。

以下是一个查询示例，它列出了最近的会话和操作历史：




SELECT username, 
       session_id, 
       timestamp, 
       action_name, 
       sql_text
FROM dba_audit_trail
ORDER BY timestamp DESC;

请注意，DBA_AUDIT_TRAIL视图可能不包含所有类型的操作历史，具体取决于数据库的审计设置。如果你需要查看更全面的历史记录，可能需要启用更多的审计选项。

如果你没有DBA角色的权限，你可以尝试使用USER_AUDIT_TRAIL视图，这将只显示当前用户的审计记录：




SELECT session_id, 
       timestamp, 
       action_name, 
       sql_text
FROM user_audit_trail
ORDER BY timestamp DESC;

确保你有足够的权限来查询这些视图，否则你可能看不到所有的历史记录。

System

2024-09-02

所有,java

以下是一个使用Spring Boot整合WebSocket的简单示例，实现了前后端实时通信的功能。

后端代码（Spring Boot）:




import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.*;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }
 
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
}
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
public class HomeController {
    @GetMapping("/")
    @ResponseBody
    public String home() {
        return "Welcome to WebSocket Chat!";
    }
}
 
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
 
@Controller
public class WebSocketController {
    @MessageMapping("/chat.sendMessage")
    @SendTo("/topic/public")
    public ChatMessage sendMessage(ChatMessage message) {
        return message;
    }
}
 
class ChatMessage {
    private String content;
    // getters and setters
}

前端代码（HTML + JavaScript）:




<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Chat</title>
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.7.0/dist/sockjs.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/stomp.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/jquery@3.5.1/dist/jquery.min.js"></script>
</head>
<body>
    <div>
        <input type="text" id="name" placeholder="Your Name" />
        <button id="connect">Connect</button>
        <button id="disconnect">Disconnect</button>
        <input type="text" id="message" placeholder="Message" />
        <button id="send">Send Message</button>
        <div id="conversationDiv">
            <label for="conversation">Conversation:</label>
            <textarea id="conversation" rows="4" cols="50"></textarea>
        </div>
    </div>
    <script>
        var stompClient = null;
        $('#con

- 阅读更多 -

Linux中oracle备份脚本

System

2024-09-02

所有,数据库

以下是一个简单的Linux shell脚本示例，用于自动化Oracle数据库的备份。请确保根据您的环境修改脚本中的环境变量，如ORACLE_HOME，ORACLE_SID，BACKUP_DIR，以及其他任何特定设置。




#!/bin/bash
 
# 设置Oracle环境变量
export ORACLE_HOME=/u01/app/oracle/product/11.2.0/db_1
export ORACLE_SID=ORCL
export BACKUP_DIR=/backup/oracle
 
# 创建备份目录
mkdir -p $BACKUP_DIR
 
# 备份数据库
expdp system/password@$ORACLE_SID schemas=YOUR_SCHEMA directory=DATA_PUMP_DIR dumpfile=your_schema_backup.dmp logfile=your_schema_backup.log
 
# 压缩备份文件
cd $BACKUP_DIR
tar -czf your_schema_backup_$(date +%Y%m%d).tar.gz your_schema_backup.dmp your_schema_backup.log
 
# 删除原始备份文件，只保留压缩后的备份
rm your_schema_backup.dmp your_schema_backup.log
 
# 删除旧的备份文件，保留最近7天的备份
find $BACKUP_DIR -name "your_schema_backup_*.tar.gz" -mtime +7 -exec rm -f {} \;

确保该脚本有执行权限，可以通过以下命令赋予执行权限并执行：




chmod +x backup_oracle.sh
./backup_oracle.sh

这个脚本会备份指定的schema，并将备份文件压缩存储在指定的目录。同时，它会删除超过7天的旧备份文件，以保持备份的存储空间。注意替换YOUR_SCHEMA为实际使用的schema名称，以及替换system/password为实际的Oracle用户和密码。

System

2024-09-02

所有,java

Retrofit是一个类型安全的HTTP客户端的Java库，它适用于Android，但也可以在Java后端应用中使用。以下是一个简单的例子，展示如何使用Retrofit来替代Spring Boot中的RestTemplate。

首先，添加Retrofit依赖到你的build.gradle文件中：




implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

然后，定义一个API接口：




public interface GitHubService {
    @GET("users/{user}/repos")
    Call<List<Repo>> listRepos(@Path("user") String user);
}

接下来，使用Retrofit创建一个实例：




Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();
 
GitHubService service = retrofit.create(GitHubService.class);

最后，发起网络请求：




Call<List<Repo>> repos = service.listRepos("square");
repos.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
        List<Repo> repoList = response.body();
        // 处理响应
    }
 
    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {
        // 处理错误
    }
});

这个例子展示了如何使用Retrofit来获取GitHub用户的仓库列表。与RestTemplate相比，Retrofit的优势在于它的类型安全性和函数式编程风格，使得代码更加简洁和易于维护。

- 阅读更多 -

spring6-实现简易版IOC容器

System

2024-09-02

所有,java

以下是一个简化版的Spring框架的IOC容器实现，仅包含核心功能：




import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.SimpleBeanDefinitionRegistry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import java.util.Map;
 
public class SimpleIOCContainer implements ApplicationContext {
 
    private BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
 
    public void registerBean(String beanName, BeanDefinition beanDefinition) {
        registry.registerBeanDefinition(beanName, beanDefinition);
    }
 
    public Object getBean(String name) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(name);
        // 实例化Bean的逻辑（简化版本）
        return instantiateBean(beanDefinition);
    }
 
    private Object instantiateBean(BeanDefinition beanDefinition) {
        // 假设这里有实例化Bean的逻辑
        return "Instance of " + beanDefinition.getBeanClassName();
    }
 
    public <T> T getBean(String name, Class<T> requiredType) {
        return (T) getBean(name);
    }
 
    public Object getBean(String name, Object... args) {
        return getBean(name);
    }
 
    public <T> T getBean(Class<T> requiredType) {
        return getBean(requiredType.getSimpleName(), requiredType);
    }
 
    public <T> Map<String, T> getBeansOfType(Class<T> type) {
        // 实现获取所有指定类型Bean的逻辑
        return null;
    }
 
    // 其他ApplicationContext接口方法的实现...
}

这个简化版的SimpleIOCContainer类实现了ApplicationContext接口的核心方法，包括注册Bean定义、获取Bean等。在instantiateBean方法中，假设有实例化Bean的逻辑，通常这会涉及到反射、工厂方法等。

使用这个容器的方式如下：




public class Main {
    public static void main(String[] args) {
        SimpleIOCContainer container = new SimpleIOCContainer();
 
        // 注册一个Bean
        BeanDefinition beanDefinition = new RootBeanDefinition(MyBean.class);
        container.registerBean("myBean", beanDefinition

- 阅读更多 -