1. 首页
  2. 分类
  3. 后端技术
【JavaWeb】Tomcat的配置与初识Servlet
System
2024-09-04
所有,java

在JavaWeb中，Tomcat是一个流行的Servlet容器，用于运行基于Java的Web应用程序。以下是如何配置Tomcat和创建一个简单的Servlet的步骤和示例代码。

  1. 安装Tomcat：

    • 从Tomcat官网下载Tomcat的最新版本。
    • 解压到你的工作目录。

  2. 配置Tomcat：

    • 确保JAVA\_HOME环境变量设置正确，指向你的JDK安装目录。

  3. 创建一个简单的Servlet：

    使用文本编辑器创建一个简单的Servlet类。




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>");
    }
}

  1. 编译Servlet：

    使用javac命令行工具编译上面的Servlet。




javac HelloWorldServlet.java

  1. 部署Servlet到Tomcat：

    • 将编译后的.class文件复制到Tomcat的webapps目录下的对应Web应用的WEB-INF/classes目录中，或者打包成war文件放入webapps目录。
    • 如果是打包成war，可以使用jar命令创建：



jar cvf HelloWorld.war *

  1. 启动Tomcat：

    • 进入Tomcat安装目录下的bin文件夹。
    • 运行startup.sh（Linux/Unix）或startup.bat（Windows）脚本启动Tomcat。

  2. 测试Servlet：

    • 打开浏览器，访问http://localhost:8080/你的Web应用路径/HelloWorldServlet。

以上步骤和代码展示了如何配置Tomcat，创建一个简单的Servlet，编译并部署到Tomcat中，最后通过浏览器访问这个Servlet。

- 阅读更多 -
本地部署Stable Diffusion WebUI
System
2024-09-04
所有,AIGC

在部署Stable Diffusion WebUI时，你需要遵循以下步骤：

  1. 确保你有一个运行中的Stable Diffusion模型。
  2. 安装Python环境和必要的库。
  3. 下载Stable Diffusion WebUI源代码。
  4. 配置WebUI的配置文件。
  5. 启动WebUI服务。

以下是一个简化的示例流程：




# 克隆代码仓库
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui
 
# 创建Python虚拟环境（可选）
python3 -m venv venv
source venv/bin/activate
 
# 安装依赖
pip install -r requirements.txt
 
# 修改配置文件config.yaml，确保模型路径正确
# 启动WebUI
python launch.py --listen --port 7860 --model-name "1570" --precision full --no-half --disable-progress

确保替换--model-name参数为你的Stable Diffusion模型名称，--port为你想要监听的端口。

这个例子假设你已经有了Python和git的基本使用经验，并且你的Stable Diffusion模型已经准备好被WebUI调用。如果你在安装过程中遇到问题，请检查错误信息，并查找相关的解决方案。

- 阅读更多 -
内容协商源码解析与自定义 MessageConverter
System
2024-09-04
所有,java



import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
 
import java.util.List;
 
@RestController
public class ContentNegotiationExample {
 
    // 注册自定义的 MessageConverter
    @GetMapping("/registerCustomConverter")
    public String registerCustomConverter(RequestMappingHandlerAdapter adapter) {
        HttpMessageConverter<?> customConverter = new CustomHttpMessageConverter();
        adapter.getMessageConverters().add(customConverter);
        return "自定义 MessageConverter 已注册";
    }
 
    // 自定义 MessageConverter 示例
    public static class CustomHttpMessageConverter extends MappingJackson2HttpMessageConverter {
        CustomHttpMessageConverter() {
            super.setSupportedMediaTypes(List.of(MediaType.TEXT_PLAIN));
        }
        // 实现 convert 方法进行具体的消息转换逻辑
    }
}

这个代码示例展示了如何在Spring MVC中注册一个自定义的HttpMessageConverter。在registerCustomConverter方法中，我们接受一个RequestMappingHandlerAdapter对象作为参数，并将自定义的HttpMessageConverter添加到适配器的转换器列表中。自定义的CustomHttpMessageConverter继承自MappingJackson2HttpMessageConverter，并重写了其构造函数来设置支持的媒体类型为MediaType.TEXT_PLAIN。这个例子简单明了地展示了如何扩展和配置Spring MVC的消息转换系统。

- 阅读更多 -
Redis 集群搭建
System
2024-09-04
所有,redis

在搭建Redis集群时，通常需要以下几个步骤：

  1. 准备节点：每个节点运行在不同的端口。
  2. 配置节点：设置节点间的通信。
  3. 创建集群：使用redis-cli创建集群。

以下是一个简单的Redis集群搭建示例：

  1. 安装Redis并确保redis-cli和redis-server在PATH中。
  2. 配置Redis实例，创建三个配置文件redis7000.conf, redis7001.conf, redis7002.conf，并修改以下设置：



port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
  1. 启动Redis实例：



redis-server redis7000.conf
redis-server redis7001.conf
redis-server redis7002.conf
  1. 创建集群：



redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 --cluster-replicas 1

这个命令会提示你确认集群配置，然后它会自动分配节点和副本。

确保你有至少三个Redis实例运行在不同的端口，并且防火墙设置允许相应端口的流量。如果你在云服务或虚拟机上操作，请确保安全组或网络访问控制列表 (ACLs) 允许相应的端口通信。

- 阅读更多 -
Python 操作 Redis 数据库
System
2024-09-04
所有,redis

要在Python中操作Redis数据库，可以使用redis-py库。以下是一些基本操作的示例代码：

首先，安装redis-py库（如果尚未安装）：




pip install redis

然后，可以使用以下Python代码操作Redis：




import redis
 
# 连接到本地Redis实例
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 设置键值对
r.set('key', 'value')
 
# 获取键的值
value = r.get('key')
print(value)  # 输出 b'value'（字节字符串形式）
 
# 获取键的值并转换为字符串
value = r.get('key').decode('utf-8')
print(value)  # 输出 'value'
 
# 删除键
r.delete('key')
 
# 检查键是否存在
exists = r.exists('key')
print(exists)  # 输出 True 或 False
 
# 列表操作
r.rpush('mylist', 'item1')
r.rpush('mylist', 'item2')
items = r.lrange('mylist', 0, -1)
print(items)  # 输出 b'item1' 和 b'item2' 的字节字符串列表
 
# 关闭连接
r.close()

这些操作涵盖了基本的Redis键值对设置、获取、删除，以及列表的推入和获取。记得在实际应用中根据需要处理字节字符串和序列化问题。

- 阅读更多 -
IDEA+Java+JSP+Mysql+Tomcat实现Web学校教材管理系统
System
2024-09-04
所有,java

这个项目涉及的内容较多，我们将提供一个简化版本的代码示例，展示如何在IntelliJ IDEA中创建一个简单的JSP Web项目，并连接到MySQL数据库。

  1. 打开IntelliJ IDEA，创建一个新的Web项目。
  2. 配置项目的数据库连接，使用JDBC连接MySQL数据库。
  3. 创建一个简单的JSP页面，用于显示从数据库中查询到的数据。

以下是一个简化版本的DbUtil.java数据库连接工具类的代码示例：




import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
public class DbUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/college_library_system?useSSL=false&serverTimezone=UTC";
    private static final String USER = "root";
    private static final String PASSWORD = "password";
 
    public static Connection getConnection() throws SQLException {
        Connection conn = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return conn;
    }
}

以下是一个简化版本的list_books.jsp页面的代码示例，用于展示图书列表：




<%@ page import="java.sql.*" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>图书列表</title>
</head>
<body>
<%
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    try {
        conn = DbUtil.getConnection();
        stmt = conn.createStatement();
        rs = stmt.executeQuery("SELECT book_id, book_name, author FROM books");
        %>
        <h2>图书列表</h2>
        <table border="1">
            <tr>
                <th>图书ID</th>
                <th>图书名称</th>
                <th>作者</th>
            </tr>
            <% while (rs.next()) { %>
                <tr>
                    <td><%= rs.getString("book_id") %></td>
                    <td><%= rs.getString("book_name") %></td>
                    <td><%= rs.getString("author") %></td>
                </tr>
            <% } %>
        </table>
        <%
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        try { if (rs != null) rs.close(); } catch (SQLException e) { e.printStackTrace(); }
        try { if (stmt != null) stmt.close(); } catch (SQLException e) { e.printStackTrace(); }
        try { if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); }
    }
%>
</body>
</html>

这个简化版本的代码展示了如何在JSP页面中嵌入Java代码来从数据

- 阅读更多 -
SQLITE 日期格式转换
System
2024-09-04
所有,数据库

在SQLite中，可以使用内置的date()函数来格式化日期。如果你想要将一个日期字符串转换成特定的格式，可以使用以下SQL语句模板：




SELECT date(your_date_column, 'format_modifier') FROM your_table;

其中format_modifier是一个可选的字符串，用来指定输出格式。如果省略，默认格式是YYYY-MM-DD。

例如，如果你想要将一个日期转换成YYYY-MM-DD格式，你可以这样做：




SELECT date(your_date_column) FROM your_table;

如果你想要转换成MM/DD/YYYY格式，可以这样做：




SELECT date(your_date_column, 'MM/DD/YYYY') FROM your_table;

请注意，SQLite的date()函数只能用于日期格式的转换，不能用于创建新的日期。如果你需要创建一个日期对象，你可能需要使用其他SQLite或者外部语言的功能。

- 阅读更多 -
springboot3使用​自定义注解＋Jackson优雅实现接口数据脱敏
System
2024-09-04
所有,java

在Spring Boot 3中，你可以通过自定义注解和Jackson的@JsonSerializer来实现数据脱敏。以下是一个简单的例子：

  1. 自定义注解@DataMasking:



@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = DataMaskingSerializer.class)
public @interface DataMasking {
}
  1. 自定义数据脱敏的Serializer:



public class DataMaskingSerializer extends StdScalarSerializer<Object> implements ContextualSerializer {
 
    protected DataMaskingSerializer() {
        super(Object.class);
    }
 
    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        // 实现数据脱敏逻辑，例如用星号*替换部分字符
        String maskedValue = maskingLogic(value.toString());
        gen.writeString(maskedValue);
    }
 
    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
        return new DataMaskingSerializer();
    }
 
    private String maskingLogic(String value) {
        // 实现脱敏逻辑
        return "***"; // 举例，使用星号脱敏
    }
}
  1. 在实体类中使用@DataMasking注解:



public class User {
 
    private String id;
 
    @DataMasking
    private String username;
 
    // getters and setters
}
  1. 在application.properties或application.yml中配置Jackson:



spring.jackson.serialization.indent-output=true

使用上述配置，当你返回带有@DataMasking注解的字段的对象时，Jackson会自动使用DataMaskingSerializer进行数据脱敏处理。

- 阅读更多 -
Redis-分布式锁
System
2024-09-04
所有,redis

在Redis中实现分布式锁通常使用SETNX命令（或在Redis 2.6.12以上版本中使用SET key value EX max-lock-time NX命令，这样可以一次性设置并加锁，避免了两条命令之间客户端可能挂掉的问题），然后使用EXPIRE命令来给锁设置一个过期时间，以防服务器崩溃导致锁未被释放。

以下是一个使用SET命令实现分布式锁的Python示例，使用redis-py库：




import redis
import time
import uuid
 
def acquire_lock(conn, lock_name, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())  # 生成一个唯一的ID
    end = time.time() + acquire_timeout
 
    while time.time() < end:
        if conn.set(lock_name, identifier, ex=lock_timeout, nx=True):
            return identifier  # 加锁成功
        time.sleep(0.001)
 
    return False  # 在规定时间内未能获得锁
 
def release_lock(conn, lock_name, identifier):
    pipe = conn.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False  # 释放锁失败，可能因为锁已被其他客户端修改
 
# 使用示例
client = redis.StrictRedis(host='localhost', port=6379, db=0)
lock_name = "my_lock"
lock_identifier = acquire_lock(client, lock_name)
if lock_identifier:
    try:
        # 在这个区块内执行需要互斥的操作
    finally:
        if not release_lock(client, lock_name, lock_identifier):
            print("Failed to release lock")
else:
    print("Failed to acquire lock")

在这个示例中，acquire_lock 函数尝试获取锁，如果在指定时间内未能获得锁，则返回False。release_lock 函数尝试释放锁，如果锁不属于指定的ID或者因为WATCH失败，则返回False。这个实现使用了Redis的事务和watch命令来保证锁的安全性。

- 阅读更多 -
SpringBoot中集成Redis
System
2024-09-04
所有,redis

在Spring Boot中集成Redis，首先需要添加Spring Data Redis和Jedis的依赖。以下是pom.xml中的依赖配置示例：




<dependencies>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- Jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
</dependencies>

接下来，在application.properties或application.yml中配置Redis连接信息：




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

然后，你可以使用RedisTemplate或StringRedisTemplate来操作Redis：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
 
@RestController
public class RedisController {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    @GetMapping("/set/{key}/{value}")
    public String set(@PathVariable String key, @PathVariable Object value) {
        redisTemplate.opsForValue().set(key, value);
        return "success";
    }
 
    @GetMapping("/get/{key}")
    public Object get(@PathVariable String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

以上代码提供了两个简单的API：一个用于设置键值对到Redis，另一个用于从Redis中获取键对应的值。这只是集成Redis的基本示例，实际应用中可能需要更复杂的配置和操作。

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