分类后端技术下的文章

2024-09-04

为了隐藏Tomcat的版本号，可以通过修改Tomcat的默认首页来实现。以下是步骤和示例代码：

打开Tomcat的安装目录，进入到 webapps/ROOT 目录。
删除或重命名 index.jsp 文件。
如果存在 index.html 文件，编辑该文件以移除版本信息。
确保 web.xml 文件中没有配置错误，这样可以阻止Tomcat展示默认的错误页面。

关闭Tomcat的默认管理页面，可以通过以下步骤：

打开Tomcat的安装目录，进入到 conf 目录。
编辑 tomcat-users.xml 文件，移除或更改管理用户的配置。
修改 web.xml 文件，注释掉或删除关于manager应用的配置。

示例代码：




<!-- tomcat-users.xml -->
<tomcat-users>
  <!-- 移除或注释掉所有的<user>元素 -->
  <!-- <user username="admin" password="password" roles="manager-gui,admin-gui"/> -->
</tomcat-users>
 
<!-- web.xml -->
<!-- 注释掉或删除manager应用的context -->
<!--
<context path="/manager" docBase="manager" debug="0" privileged="true">
  <servlet>
    <servlet-name>HTMLManagerServlet</servlet-name>
    <servlet-class>org.apache.catalina.manager.HTMLManagerServlet</servlet-class>
    <load-on-startup>3</load-on-startup>
  </servlet>
  ...
</context>
-->

确保在修改配置后重启Tomcat以使更改生效。

初始Tomcat（Tomcat的基础介绍）

2024-09-04

Tomcat是一个开源的Java Servlet容器，也被称为Web服务器或Servlet容器，它是Apache软件基金会的一个核心项目，由Apache，Sun和其他一些公司贡献。

Tomcat主要用于服务器端处理Servlet和JSP的请求，但它也可以用作一个Web服务器来处理HTML请求。

Tomcat是一个中间件，意味着它处于客户端和服务器应用程序之间，并且可以与许多不同的客户端交互。

Tomcat的主要特点包括：

开源：Tomcat是开源的，这意味着它是免费的，任何人都可以使用或修改。
跨平台：Tomcat是在Java之上构建的，因此它可以在任何支持Java的平台上运行。
灵活性：Tomcat可以与各种不同的服务器应用程序一起使用，并且可以与各种不同的Content Management System（CMS）集成。
易于使用：Tomcat的安装和配置相对简单，只需几个步骤即可启动和运行。
支持最新的Java EE规范：Tomcat支持最新的Java EE规范，如Java Servlet、JavaServer Pages (JSP)、Java EL、WebSocket等。

安装Tomcat：

从Apache Tomcat的官方网站下载Tomcat。
解压缩下载的文件到指定的文件夹。
设置环境变量CATALINA\_HOME指向Tomcat的安装目录。
通过运行bin/startup.sh(for Unix/Linux/Mac)或bin/startup.bat(for Windows)启动Tomcat。
打开浏览器并输入http://localhost:8080/，如果看到Tomcat的欢迎页面，说明Tomcat已经成功安装并运行。

以下是一个简单的Servlet示例，展示了如何使用Java编写一个简单的Servlet并部署到Tomcat中：




import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class HelloWorldServlet 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>");
    }
}

将编译后的HelloWorldServlet.class文件放置到<Tomcat安装目录>/webapps/ROOT目录下，然后重启Tomcat。

最后，通过浏览器访问http://localhost:8080/HelloWorldServlet，你将看到输出"Hello World"。

Spring Boot与MyBatis完美融合：整合实战指南

2024-09-04




// 引入Spring Boot和MyBatis相关依赖
 
// 定义一个Spring Boot应用
@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}
 
// 定义一个Mapper接口
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(@Param("id") int id);
}
 
// 定义一个Service组件
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
 
    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }
}
 
// 定义一个Controller组件
@RestController
public class UserController {
    @Autowired
    private UserService userService;
 
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") int id) {
        return userService.getUserById(id);
    }
}
 
// 实体类User
public class User {
    private int id;
    private String name;
    // 省略getter和setter方法
}
 
// 在application.properties或application.yml中配置数据库连接等信息

这个代码实例展示了如何在Spring Boot应用中整合MyBatis。首先定义了一个Spring Boot应用类，然后创建了一个Mapper接口，其中定义了一个方法用来从数据库中通过ID查询用户。接着定义了一个Service组件，它使用了刚才定义的Mapper，并且定义了一个Controller组件，它提供了一个接口来查询用户信息。最后，定义了一个简单的实体类User来表示用户数据。在配置文件中需要配置数据库连接等信息。这个例子展示了如何将MyBatis整合到Spring Boot项目中，并提供了一个简单的用户查询接口。

暗星·Java实战之入门小程序

2024-09-04




// 导入必要的类
import acm.program.*;
 
// 创建MagicSquare类继承自MagicSquareProgram类
public class MagicSquare extends MagicSquareProgram {
    // 重写action()方法，实现功能
    public void action() {
        // 获取用户输入的数字
        int n = getInteger("Enter a number: ");
        // 调用并显示结果
        println("Here is a magic square of order " + n + ":");
        printMagicSquare(n);
    }
}

这段代码继承自MagicSquareProgram类，并重写了action方法。它提示用户输入一个数字，然后显示一个魔方矩阵。这个示例展示了如何从用户获取输入，并在控制台上显示结果，这是编程入门的基本技能。

Windows系统搭建Oracle结合内网穿透实现公网访问本地数据库

2024-09-04

在Windows系统上搭建Oracle数据库并实现公网访问，可以通过内网穿透工具来实现。以下是一个简化的步骤和示例：

安装Oracle数据库：
- 下载Oracle数据库软件。
- 安装Oracle数据库。
配置Oracle监听器和数据库：
- 配置监听器（listener.ora）。
- 配置数据库实例。
使用内网穿透工具：
- 下载并安装内网穿透工具，如ngrok或frp。
- 启动内网穿透服务，并获取公网地址。
配置Oracle数据库以允许远程连接：
- 修改tnsnames.ora文件，添加公网地址。
- 修改数据库参数以允许远程连接（例如remote_login_passwordfile）。
连接公网Oracle数据库：
- 使用数据库客户端工具，如SQL*Plus或SQL Developer，通过公网地址连接到数据库。

示例代码或命令不适用于此情境，因为涉及配置文件的编辑和内网穿透工具的使用，这些通常是通过图形用户界面操作的管理任务。

请注意，实际操作中可能需要配置防火墙规则、Oracle网络配置和数据库安全设置，确保公网访问安全。

7牛云实现上传本地文件夹的所有文件

2024-09-04

要使用七牛云的 Java SDK 实现上传本地文件夹中的所有文件，你需要先安装 SDK，并使用其提供的 API 来上传文件。以下是一个简单的例子，展示了如何使用七牛云 Java SDK 上传本地文件夹到七牛云存储空间。

首先，确保你已经添加了七牛云 Java SDK 的依赖到你的项目中。如果你使用 Maven，可以在 pom.xml 中添加如下依赖：




<dependency>
    <groupId>com.qiniu</groupId>
    <artifactId>qiniu-java-sdk</artifactId>
    <version>[最新版本号]</version>
</dependency>

然后，使用以下代码上传本地文件夹：




import com.qiniu.common.QiniuException;
import com.qiniu.http.Response;
import com.qiniu.storage.UploadManager;
import com.qiniu.util.Auth;
 
import java.io.File;
 
public class QiniuUploadFolder {
 
    // 设置好访问密钥和密钥
    private static final String ACCESS_KEY = "你的AccessKey";
    private static final String SECRET_KEY = "你的SecretKey";
    // 要上传的本地目录
    private static final String localDir = "本地文件夹路径";
    // 构造上传的token
    private static final String bucket = "你的bucket名字";
    private static final Auth auth = Auth.create(ACCESS_KEY, SECRET_KEY);
    private static final UploadManager uploadManager = new UploadManager();
 
    public static void main(String[] args) {
        try {
            File fileDir = new File(localDir);
            if (fileDir.isDirectory()) {
                File[] files = fileDir.listFiles();
                for (File file : files) {
                    if (file.isFile()) {
                        String key = file.getName();
                        String token = auth.uploadToken(bucket);
                        try {
                            Response response = uploadManager.put(file, key, token);
                            // 解析上传成功的结果
                            DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
                            System.out.println(putRet.key);
                            System.out.println(putRet.hash);
                        } catch (QiniuException ex) {
                            Response r = ex.response;
                            System.err.println(r.toString());
                            try {
                                System.err.println(r.bodyString());
                            } catch (QiniuException ex2) {
                                // ignore
                            }
                        }
                    }

2024-09-04

在PostgreSQL中，清理dead tuples通常是通过VACUUM或VACUUM FULL命令来完成的。

VACUUM命令用于清理表中的死元组（dead tuples），它会重新组织表中的存储空间，并且可以清理未使用的空间。这个命令不会重建索引，也不会移动表到新的物理位置。

VACUUM FULL命令则是一个更加详尽的清理操作，它会进行与VACUUM相同的工作，同时还会重建所有索引，并且可以移动表到新的物理位置以减少碎片。

以下是使用VACUUM和VACUUM FULL的SQL命令示例：




-- 清理特定表的dead tuples
VACUUM table_name;
 
-- 清理特定表并重建索引
VACUUM FULL table_name;
 
-- 清理数据库中所有表的dead tuples
VACUUM;
 
-- 清理数据库中所有表并重建所有索引
VACUUM FULL;

在实际操作中，应该根据实际情况选择合适的命令，如果经常有大量的数据被删除，可能需要频繁运行VACUUM或VACUUM FULL命令。如果系统资源有限，应该避免频繁运行这些命令。

Mongodb新增文档、查询文档、更新文档、删除文档

2024-09-04

在MongoDB中，您可以使用MongoDB shell或者使用编程语言中的MongoDB驱动来执行以下操作：

新增文档（插入文档）：




// 使用MongoDB shell
db.collection.insertOne({key: 'value'}) // 插入单个文档
db.collection.insertMany([{key1: 'value1'}, {key2: 'value2'}]) // 插入多个文档
 
// 使用Node.js MongoDB驱动
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
const dbName = 'mydatabase';
const client = new MongoClient(url);
 
async function insertDocuments() {
  try {
    await client.connect();
    console.log('Connected to server');
    const db = client.db(dbName);
    const collection = db.collection('collection');
    
    const insertOneResult = await collection.insertOne({key: 'value'});
    console.log('InsertOne Result:', insertOneResult.insertedId);
 
    const insertManyResult = await collection.insertMany([{key1: 'value1'}, {key2: 'value2'}]);
    console.log('InsertMany Result:', insertManyResult.insertedIds);
  } finally {
    await client.close();
  }
}
 
insertDocuments().catch(console.error);

查询文档：




// 使用MongoDB shell
db.collection.find({key: 'value'})
 
// 使用Node.js MongoDB驱动
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
const dbName = 'mydatabase';
const client = new MongoClient(url);
 
async function findDocuments() {
  try {
    await client.connect();
    console.log('Connected to server');
    const db = client.db(dbName);
    const collection = db.collection('collection');
    
    const query = {key: 'value'};
    const docs = await collection.find(query).toArray();
    console.log('Found Documents:', docs);
  } finally {
    await client.close();
  }
}
 
findDocuments().catch(console.error);

更新文档：




// 使用MongoDB shell
db.collection.updateOne({key: 'value'}, {$set: {key: 'newValue'}}) // 更新单个文档
db.collection.updateMany({key: 'value'}, {$set: {key: 'newValue'}}) // 更新多个文档
 
// 使用Node.js MongoDB驱动
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
const dbName = 'mydatabase';
const client = new MongoClient(url);

Unity接入SQLite :C#封装SQL命令

2024-09-04




using System.Data.SQLite;
 
public class SQLiteHelper
{
    private string connectionString;
 
    public SQLiteHelper(string dbPath)
    {
        connectionString = $"Data Source={dbPath}";
    }
 
    public void ExecuteNonQuery(string query)
    {
        using (var connection = new SQLiteConnection(connectionString))
        {
            connection.Open();
            using (var command = new SQLiteCommand(query, connection))
            {
                command.ExecuteNonQuery();
            }
        }
    }
 
    public SQLiteDataReader ExecuteReader(string query)
    {
        var connection = new SQLiteConnection(connectionString);
        connection.Open();
        var command = new SQLiteCommand(query, connection);
        return command.ExecuteReader();
    }
 
    public object ExecuteScalar(string query)
    {
        using (var connection = new SQLiteConnection(connectionString))
        {
            connection.Open();
            using (var command = new SQLiteCommand(query, connection))
            {
                return command.ExecuteScalar();
            }
        }
    }
}

这个代码示例展示了如何封装SQLite数据库操作的基本命令，包括执行非查询命令（如INSERT、UPDATE、DELETE）、执行查询命令并返回结果集以及执行查询命令并返回结果集中的第一行的第一列。这些封装方法可以简化数据库操作，并减少代码中的重复和错误。

Oracle知识整合----SQL概述

2024-09-04

在Oracle数据库中，SQL是一种用于管理数据、查询数据、定义数据、控制和管理数据库操作的标准语言。以下是一些SQL的基本概念和使用方法。

数据定义语言（DDL）

数据定义语言（DDL）是用于创建或删除数据库对象的语言，如表、视图和索引等。




-- 创建表
CREATE TABLE employees (
    id NUMBER PRIMARY KEY,
    name VARCHAR2(50),
    job_role VARCHAR2(50),
    salary NUMBER
);
 
-- 删除表
DROP TABLE employees;

数据操纵语言（DML）

数据操纵语言（DML）是用于查询和更新数据库中的数据的语言。




-- 插入数据
INSERT INTO employees (id, name, job_role, salary) VALUES (1, 'John Doe', 'Developer', 80000);
 
-- 更新数据
UPDATE employees SET salary = 90000 WHERE id = 1;
 
-- 删除数据
DELETE FROM employees WHERE id = 1;

事务控制语言（TCL）

事务控制语言（TCL）用于管理数据库事务。




-- 开始事务
START TRANSACTION;
 
-- 提交事务
COMMIT;
 
-- 回滚事务
ROLLBACK;

数据控制语言（DCL）

数据控制语言（DCL）用于管理数据库的访问权限和安全性。




-- 授权
GRANT SELECT, INSERT ON employees TO user_name;
 
-- 撤销权限
REVOKE SELECT, INSERT ON employees FROM user_name;

数据查询语言（DQL）

数据查询语言（DQL）用于从数据库中查询数据。




-- 查询数据
SELECT * FROM employees;

以上是Oracle SQL的基本概念和使用方法，实际使用时需要根据具体的数据库结构和业务需求来编写相应的SQL语句。