1. 首页
  2. 分类
  3. 后端技术
bat脚本后台运行tomcat的startup.bat
System
2024-09-03
所有,java

在Windows环境下，你可以创建一个新的批处理文件（.bat）来在后台运行Tomcat的startup.bat。以下是一个简单的批处理脚本示例，它会启动Tomcat并将其放在后台运行：




@echo off
start /b call "C:\path\to\tomcat\bin\startup.bat"

请将"C:\path\to\tomcat\bin\startup.bat"替换为你的Tomcat安装目录中的startup.bat文件的实际路径。

这个批处理文件将启动一个新的命令行界面（通过start命令），并且使用call命令来调用startup.bat，这样它就会在新的命令行界面中运行，同时这个界面会在后台运行。

如果你想要关闭这个后台进程，你可以直接关闭那个命令行界面，或者使用任务管理器来结束相关的进程。

- 阅读更多 -
SpringSecurity+OAuth2.0 搭建认证中心和资源服务中心
System
2024-09-03
所有,java

以下是一个简化的Spring Security和OAuth2.0搭配使用的示例，用于搭建一个认证中心和资源服务中心。

认证中心（Authorization Server）:




@Configuration
@EnableAuthorizationServer
public class AuthServerConfig extends AuthorizationServerConfigurerAdapter {
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
            .withClient("resource-server")
            .secret("secret")
            .authorizedGrantTypes("client_credentials")
            .scopes("read", "write")
            .resourceIds("oauth2-resource");
    }
 
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager);
    }
}

资源服务中心（Resource Server）:




@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
 
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .anyRequest().authenticated();
    }
 
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("oauth2-resource");
    }
}

安全配置（Security Configuration）:




@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("password").authorities("USER");
    }
 
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

启动类（Application）:




@SpringBootApplication
public class AuthServerApplication {
 
    publ
- 阅读更多 -
SpringBoot项目启动内存泄漏问题排查与解决
System
2024-09-03
所有,java



import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
 
@SpringBootApplication
public class MemoryLeakApplication {
 
    public static void main(String[] args) {
        // 启动Spring Boot应用
        SpringApplication app = new SpringApplication(MemoryLeakApplication.class);
        ConfigurableApplicationContext context = app.run(args);
 
        // 执行你的业务逻辑操作
 
        // 关闭Spring应用上下文以防止内存泄漏
        context.close();
    }
}

在这个例子中，我们启动了一个Spring Boot应用，并在业务处理完成后关闭了Spring应用上下文。这是一个常规操作，可以防止内存泄漏。如果发现内存泄漏，可以通过JMX、JVisualVM或其他JVM监测工具进一步分析和解决问题。

- 阅读更多 -
PostgreSQL 实现 Oracle 多表插入语句
System
2024-09-03
所有,数据库

在PostgreSQL中，你可以使用INSERT INTO ... SELECT ...语句来实现Oracle的多表插入。以下是一个示例，它展示了如何将数据从一个表插入到另一个表中：




-- 假设存在两个表 table_source 和 table_target，它们具有相同的结构
-- 在PostgreSQL中，你可以使用以下语句进行多表插入
 
INSERT INTO table_target (column1, column2, column3)
SELECT column1, column2, column3
FROM table_source
WHERE condition; -- 这里可以指定你需要插入的数据的条件

如果你需要同时向多个表中插入数据，你可以分别为每个表编写上述的INSERT INTO ... SELECT ...语句。

请注意，PostgreSQL不支持Oracle中的ALL关键字，这意味着在PostgreSQL中你不能一次性向多个行中插入数据。你需要为每一行分别执行INSERT语句。

- 阅读更多 -
SpringBoot——嵌入式 Servlet容器
System
2024-09-03
所有,java

Spring Boot 使用嵌入式 Servlet 容器，意味着你不需要部署 WAR 文件到外部容器中，Spring Boot 会对 Tomcat、Jetty 或 Undertow 等进行封装，并内置了这些容器，使得你可以直接将应用打包成一个可执行的 JAR 文件，通过 Java -jar 命令就可以运行应用。

以下是一个简单的 Spring Boot 应用示例，使用了内嵌的 Tomcat 作为 Servlet 容器：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
 
@SpringBootApplication
public class ServletContainerApplication extends SpringBootServletInitializer {
 
    public static void main(String[] args) {
        SpringApplication.run(ServletContainerApplication.class, args);
    }
 
    // 如果需要打包成war包，需要继承SpringBootServletInitializer并重写configure方法
    @Override
    protected void configure(SpringApplicationBuilder builder) {
        builder.sources(ServletContainerApplication.class);
    }
}

在这个例子中，ServletContainerApplication 类通过继承 SpringBootServletInitializer 并重写 configure 方法来支持将应用打包成 WAR 文件。如果你不打算将应用部署为 WAR，则不需要重写 configure 方法。

当你运行 main 方法并使用 Spring Boot 的 Maven 或 Gradle 插件打包时，你可以得到一个可执行的 JAR 文件，通过 Java 命令就可以启动内嵌的 Tomcat 容器。

如果你想要打包成 WAR 文件，可以在 pom.xml 或 build.gradle 中添加相应配置，并调用 mvn package 或 gradle war 命令来生成 WAR 文件。

注意：Spring Boot 2.0 以上版本不再直接支持 WAR 文件的生成，如果你需要生成 WAR 文件，可能需要使用传统的方式进行配置或者考虑使用支持 WAR 文件的 Servlet 容器（比如 Undertow）。

- 阅读更多 -
apache+tomcat +负载平衡，系列篇
System
2024-09-03
所有,java

在Apache和Tomcat之间实现负载均衡，通常使用Apache提供的mod_proxy模块。以下是一个基本的配置示例：

  1. 确保Apache安装了mod_proxy和mod_proxy_balancer模块。
  2. 配置Apache虚拟主机（在Apache的配置文件中，如httpd.conf或虚拟主机文件中）：



<VirtualHost *:80>
    ServerName www.example.com
    
    ProxyRequests Off
    ProxyPass / balancer://mycluster/
    ProxyPassReverse / balancer://mycluster/
    
    <Proxy balancer://mycluster>
        BalancerMember http://tomcat1:8080 loadfactor=1 route=jvm1
        BalancerMember http://tomcat2:8080 loadfactor=1 route=jvm2
        # 可以添加更多的Tomcat实例
    </Proxy>
</VirtualHost>

在这个配置中：

  • ServerName 是你的网站域名。
  • ProxyRequests Off 禁用直接代理HTTP请求。
  • ProxyPass / balancer://mycluster/ 将所有请求代理到名为mycluster的负载均衡器。
  • <Proxy> 指令定义了一个名为mycluster的负载均衡器，其中包含两个成员BalancerMember，分别指向运行Tomcat的两个实例，并设置了loadfactor（负载权重）和route（用于会话维持的标识）。

确保替换tomcat1和tomcat2为你的Tomcat服务器的实际主机名或IP地址，以及更新端口（如果不是8080）。

这样配置后，所有到www.example.com的请求将通过Apache均衡地分配到Tomcat的两个实例上。loadfactor参数可以根据各个Tomcat实例的处理能力来调整负载分配。

- 阅读更多 -
【YUNBEE云贝-ORACLE】Linux x86-64 安装Oracle 23AI指南
System
2024-09-03
所有,数据库

由于原始问题提供的信息不足，以下是一个基于假设的简化版本的安装指南：




#!/bin/bash
# 安装Oracle数据库23c的示例脚本
 
# 定义Oracle软件包的下载URL
ORACLE_YUM_REPO_URL="http://yum.oracle.com/repo/OracleLinux/OL7/latest/x86_64/getPackage/oracle-database-ee-23c-1.0-1.x86_64.rpm"
 
# 安装必要的软件包和依赖
sudo yum install -y oracle-database-preinstall-23c
 
# 创建Oracle安装目录
sudo mkdir -p /u01/app/oracle
sudo chown -R oracle:oinstall /u01
sudo chmod -R 775 /u01
 
# 下载并安装Oracle数据库软件包
sudo yum install -y ${ORACLE_YUM_REPO_URL}
 
# 配置环境变量
echo "export ORACLE_HOME=/u01/app/oracle/product/23c/dbhome_1" >> ~oracle/.bashrc
echo "export PATH=\$PATH:\$ORACLE_HOME/bin" >> ~oracle/.bashrc
source ~oracle/.bashrc
 
# 设置Oracle实例
dbca -silent -createDatabase \
-templateName General_Purpose.dbc \
-gdbName yunbee_db \
-sid yunbee_db \
-createAsContainerDatabase false \
-characterSet AL32UTF8 \
-sysPassword Yunbee123 \
-systemPassword Yunbee123 \
-createSysDBA true
 
# 完成安装后的配置
sqlplus / as sysdba <<EOF
ALTER SYSTEM SET processes=1000 SCOPE=SPFILE;
ALTER SYSTEM SET sessions=1105 SCOPE=SPFILE;
ALTER SYSTEM SET sga_target=2G SCOPE=SPFILE;
ALTER SYSTEM SET pga_aggregate_target=1G SCOPE=SPFILE;
SHUTDOWN IMMEDIATE;
STARTUP;
EXIT;
EOF

这个脚本提供了一个简化的示例，展示了如何在Oracle Linux 7上安装Oracle 23c数据库的基本步骤。请注意，这个脚本假设Oracle Linux已经配置好了网络，并且有正确的软件仓库可用。在实际部署时，你需要根据自己的环境进行适当的调整，包括设置正确的环境变量、内存分配和数据库创建参数。

- 阅读更多 -
MySQL、Oracle查看字节和字符长度个数的函数length() 、char_length() 、lengthB()
System
2024-09-03
所有,数据库

在MySQL和Oracle中，LENGTH()函数和LENGTHB()函数用于获取字符串的字节长度，而CHAR_LENGTH()和LENGTH()函数用于获取字符串的字符长度。

  1. MySQL中的使用方法：
  • LENGTH(str)：返回字符串str的字节长度。
  • CHAR_LENGTH(str)：返回字符串str的字符长度。
  • LENGTHB(str)：返回字符串str的字节长度。

示例代码：




-- 创建表
CREATE TABLE TestTable(
    name VARCHAR(10)
);
 
-- 插入数据
INSERT INTO TestTable(name) VALUES('测试');
 
-- 查询字节长度
SELECT LENGTH(name) AS '字节长度', LENGTHB(name) AS '字节长度(B)' FROM TestTable;
 
-- 查询字符长度
SELECT CHAR_LENGTH(name) AS '字符长度' FROM TestTable;
  1. Oracle中的使用方法：
  • LENGTH(str)：返回字符串str的字节长度。
  • LENGTHB(str)：返回字符串str的字节长度。
  • LENGTHC(str)：返回字符串str的字符长度。

示例代码：




-- 创建表
CREATE TABLE TestTable(
    name VARCHAR2(10)
);
 
-- 插入数据
INSERT INTO TestTable(name) VALUES('测试');
 
-- 查询字节长度
SELECT LENGTH(name) AS "字节长度", LENGTHB(name) AS "字节长度(B)" FROM TestTable;
 
-- 查询字符长度
SELECT LENGTHC(name) AS "字符长度" FROM TestTable;

注意：在Oracle中，LENGTH()和LENGTHB()函数返回的是字符在特定字符集下的字节长度，而LENGTHC()返回的是字符数。

在实际使用中，需要根据数据库的不同选择合适的函数进行使用。

- 阅读更多 -
深入理解 Django 信号机制
System
2024-09-03
所有,数据库



from django.db.models import signals
from django.dispatch import receiver
from django.utils.timezone import now
 
# 假设我们有一个模型 `MyModel` 和一个与之相关的日志模型 `LogEntry`
class MyModel(models.Model):
    name = models.CharField(max_length=100)
 
class LogEntry(models.Model):
    mymodel = models.ForeignKey(MyModel, on_delete=models.CASCADE)
    action_time = models.DateTimeField(auto_now_add=True)
    action = models.CharField(max_length=100)
 
# 接收模型保存信号并创建日志条目
@receiver(signals.post_save, sender=MyModel)
def log_create(sender, **kwargs):
    if not kwargs.get('created', True):
        return
    LogEntry.objects.create(
        mymodel=kwargs['instance'],
        action='Created',
        action_time=now()
    )
 
# 接收模型删除信号并创建日志条目
@receiver(signals.post_delete, sender=MyModel)
def log_delete(sender, **kwargs):
    LogEntry.objects.create(
        mymodel=kwargs['instance'],
        action='Deleted',
        action_time=now()
    )

这个简单的例子展示了如何使用Django的信号机制来记录模型的创建和删除操作。每当有MyModel实例被创建或删除时，相应的信号会被触发，并调用log_create和log_delete函数，这两个函数会在相应的条件下创建LogEntry实例。这种方式使得日志记录的代码与业务逻辑分离，增强了代码的可维护性和可读性。

- 阅读更多 -
Springboot+Maven多模块项目开发
System
2024-09-03
所有,java

在Spring Boot中创建多模块项目，你可以使用Maven来构建。以下是创建多模块项目的步骤：

  1. 创建父项目：



mvn archetype:generate -DgroupId=com.example -DartifactId=parent-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
  1. 修改父项目的pom.xml文件，设置<packaging>为pom：



<groupId>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
  1. 在父项目目录下创建子模块：



mvn archetype:generate -DgroupId=com.example.module -DartifactId=module1 -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
  1. 修改父项目的pom.xml文件，添加子模块：



<modules>
  <module>module1</module>
</modules>
  1. 重复步骤3和4来创建更多的子模块。

以下是一个简单的多模块项目的pom.xml示例：

父项目的pom.xml:




<groupId>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
 
<modules>
  <module>module1</module>
  <module>module2</module>
</modules>
 
<properties>
  <java.version>1.8</java.version>
</properties>
 
<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>
 
<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

子模块的pom.xml示例：




<parent>
  <groupId>com.example</groupId>
  <artifactId>parent-project</artifactId>
  <version>1.0-SNAPSHOT</version>
</parent>
 
<groupId>com.example.module</groupId>
<artifactId>module1</artifactId>
 
<dependencies>
  <!-- 子模块的依赖，如果需要使用父项目的依赖，不需要再次声明 -->
</dependencies>

这样，你就创建了一个Spring Boot和Maven的多模块项目。每个子模块可以是一个Spring Boot应用，可以包含自己的Controller、Service等组件，最终可以通过父项目打包成一个可执行的JAR或WAR。

- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号