Tech Blog

Spring MVC 之 Restful 风格请求⽀持

2024-09-05




import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
@RestController
@RequestMapping("/api/items")
public class ItemController {
 
    // 假设这是一个服务组件，用于处理业务逻辑
    @Autowired
    private ItemService itemService;
 
    // 获取所有商品列表（Restful风格的查询所有）
    @GetMapping
    public ResponseEntity<List<Item>> queryAllItems() {
        List<Item> items = itemService.queryAll();
        if (items.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        return new ResponseEntity<>(items, HttpStatus.OK);
    }
 
    // 根据关键字查询商品列表（Restful风格的查询）
    @GetMapping("/search")
    public ResponseEntity<List<Item>> searchItemsByKeyword(@RequestParam String keyword) {
        List<Item> items = itemService.searchByKeyword(keyword);
        if (items.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        return new ResponseEntity<>(items, HttpStatus.OK);
    }
 
    // 根据ID查询商品详情（Restful风格的查询单个）
    @GetMapping("/{id}")
    public ResponseEntity<Item> queryItemById(@PathVariable("id") Integer id) {
        Item item = itemService.queryById(id);
        if (item == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(item, HttpStatus.OK);
    }
}

这个代码示例展示了如何在Spring MVC中使用@RestController和@GetMapping注解来创建支持Restful风格的控制器。它提供了三个基本的Restful操作：获取所有商品列表、根据关键字查询商品列表和根据ID查询商品详情。对于查询操作，它返回了相应的HTTP状态码，如HttpStatus.OK或HttpStatus.NO_CONTENT，以表示请求的结果。

使用 Django 构建动态网页

2024-09-05

在Django中创建一个简单的动态网站涉及以下步骤：

安装Django：




pip install django

创建一个新的Django项目：




django-admin startproject mysite




cd mysite
python manage.py runserver

定义模型（models.py）：




from django.db import models
 
class MyModel(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()

创建数据库迁移：




python manage.py makemigrations
python manage.py migrate

创建视图（views.py）来显示模型数据：




from django.shortcuts import render
from .models import MyModel
 
def home(request):
    items = MyModel.objects.all()
    return render(request, 'home.html', {'items': items})

定义URLs（urls.py）：




from django.urls import path
from .views import home
 
urlpatterns = [
    path('', home, name='home'),
]

创建模板（home.html）：




<!DOCTYPE html>
<html>
<head>
    <title>My Site</title>
</head>
<body>
    <h1>My Dynamic Webpage</h1>
    <ul>
        {% for item in items %}
        <li>{{ item.title }} - {{ item.description }}</li>
        {% endfor %}
    </ul>
</body>
</html>

（可选）添加管理员账户和管理界面：




python manage.py createsuperuser

（可选）定义管理界面注册模型：




# admin.py
from django.contrib import admin
from .models import MyModel
 
admin.site.register(MyModel)

以上步骤构成了一个基本的动态网站，您可以根据需求添加更多功能，例如表单处理、用户认证、高级数据库查询等。

2024-09-05

错误解释：

ORA-01704错误表示字符串字面量太长。在Oracle数据库中，当你尝试将一个超出字段最大长度限制的字符串插入CLOB类型的列时，就会遇到这个错误。

解决方法：

检查你尝试插入的字符串长度，确保它不超过CLOB字段的最大长度限制（在Oracle中，CLOB类型的最大长度是4GB）。
如果确实需要存储大量文本，可以考虑使用PL/SQL来插入数据，例如使用DBMS_LOB.SUBSTR函数来分段处理长文本数据。
另一种方法是使用Oracle提供的程序包DBMS_LOB中的WRITE或SUBSTR函数来处理大字符串。

示例代码（假设my_clob_column是CLOB类型的列）：




DECLARE
  my_clob CLOB;
BEGIN
  -- 初始化CLOB变量
  DBMS_LOB.CREATETEMPORARY(my_clob, TRUE);
  
  -- 插入字符串到CLOB变量
  DBMS_LOB.WRITE(my_clob, LENGTH('YOUR_LONG_STRING'), 1, 'YOUR_LONG_STRING');
  
  -- 将CLOB变量插入到表中
  INSERT INTO your_table (my_clob_column) VALUES (my_clob);
  
  COMMIT;
END;

确保在实际使用时，YOUR_LONG_STRING替换为你的实际长字符串，your_table替换为你的实际表名，my_clob_column替换为你的实际CLOB类型的列名。

2024-09-05




// 假设已经有一个Protobuf定义的消息，例如：
// message Person {
//   string name = 1;
//   int32 age = 2;
// }
 
// 在Spring Boot中配置Protobuf支持
@Configuration
public class ProtobufConfiguration {
 
    @Bean
    public ProtobufHttpMessageConverter protobufHttpMessageConverter() {
        return new ProtobufHttpMessageConverter();
    }
}
 
// 使用Protobuf进行数据序列化和反序列化的Controller
@RestController
public class ProtobufController {
 
    // 将HTTP请求的Protobuf消息转换为Java对象
    @PostMapping(path = "/person", consumes = "application/x-protobuf")
    public Person postPerson(@RequestBody Person person) {
        // 处理接收到的Person对象
        return person; // 假设处理后不变，直接返回
    }
 
    // 将Java对象序列化为Protobuf消息，并作为HTTP响应返回
    @GetMapping(path = "/person/{id}", produces = "application/x-protobuf")
    public ResponseEntity<Person> getPerson(@PathVariable("id") int id) {
        Person person = ...; // 获取Person对象
        return ResponseEntity.ok(person);
    }
}

这个简单的例子展示了如何在Spring Boot应用程序中配置Protobuf消息转换器，并在Controller中使用Protobuf进行数据的序列化和反序列化。在实际应用中，你需要定义相应的Protobuf消息类型，并确保Person类是根据你的.proto文件自动生成的。

yum安装postgresql

2024-09-05

在基于RPM的系统如CentOS或RHEL上，您可以使用YUM包管理器来安装PostgreSQL。以下是安装PostgreSQL的步骤：

首先，您需要确保您的系统已经配置了正确的YUM仓库，包括PostgreSQL的仓库。如果您使用的是CentOS 7或CentOS 8，您可以使用官方的PostgreSQL YUM仓库。
安装PostgreSQL。您可以通过以下命令来安装最新版本的PostgreSQL：




sudo yum install -y postgresql-server

初始化数据库：




sudo postgresql-setup initdb

启动PostgreSQL服务：




sudo systemctl enable --now postgresql

确认PostgreSQL服务正在运行：




sudo systemctl status postgresql

（可选）配置PostgreSQL。您可以通过编辑/var/lib/pgsql/data/postgresql.conf文件来调整配置，并通过pg_hba.conf来设置用户认证。
（可选）创建一个新的PostgreSQL用户和数据库：




sudo su - postgres
createuser --interactive
createdb mydatabase

请注意，上述步骤可能会根据您的系统配置和版本略有不同。如果您需要安装特定版本的PostgreSQL，您可能需要从PostgreSQL的官方网站下载对应版本的rpm包或者配置相应的仓库。

Spring Boot中使用JWT及拦截器配置以及各层次的介绍

2024-09-05




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import com.example.demo.security.jwt.JwtAuthenticationFilter;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Bean
    JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter();
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // 其他配置 ...
            .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
            // 其他配置 ...
    }
}

这段代码定义了一个SecurityConfig类，继承自WebSecurityConfigurerAdapter。它创建了一个JwtAuthenticationFilter的Bean，并在configure方法中将其添加到Spring Security的过滤器链中，并指定它在UsernamePasswordAuthenticationFilter之前。这样配置后，JWT认证过滤器会在用户名密码认证过滤器之前执行，用于处理和验证JWT token。

NodeJS+Express+MongoDB - 张果 - 博客园，深入剖析

2024-09-05

在Node.js, Express和MongoDB的环境中，以下是一个简化的代码示例，展示了如何创建一个简单的博客文章路由：




const express = require('express');
const router = express.Router();
const mongoose = require('mongoose');
 
// 定义博客文章的Schema
const BlogPostSchema = new mongoose.Schema({
  title: String,
  content: String,
  author: String,
  createdAt: { type: Date, default: Date.now }
});
 
// 创建模型
const BlogPost = mongoose.model('BlogPost', BlogPostSchema);
 
// 获取所有文章
router.get('/', async (req, res) => {
  try {
    const posts = await BlogPost.find();
    res.json(posts);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});
 
// 创建新文章
router.post('/', async (req, res) => {
  const newPost = new BlogPost(req.body);
  try {
    const savedPost = await newPost.save();
    res.status(201).json(savedPost);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});
 
// 导出路由
module.exports = router;

这段代码展示了如何使用Express和Mongoose来创建RESTful API，以便于获取和发布博客文章。它还包含了错误处理和HTTP状态代码的正确使用，这对于构建可靠的API至关重要。

Tomcat容器的I/O分析与调优

2024-09-05

在Tomcat中进行I/O分析和调优通常涉及以下几个方面：

连接器（Connector）配置：调整<Connector>配置参数，如acceptCount、maxConnections、maxThreads、minSpareThreads等。
调整JVM参数：增加堆大小，调整垃圾收集策略等。
使用Tomcat的Manager应用监控应用性能。
使用外部工具进行性能分析，如VisualVM, JProfiler, YourKit等。

以下是一个简单的<Connector>配置示例：




<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           acceptCount="100"
           maxConnections="1000"
           maxThreads="200"
           minSpareThreads="50" />

在这个例子中，acceptCount是指当所有可以使用的处理请求的线程都在使用时，可以在连接队列中等待的连接数。maxConnections是指在所有连接器上允许的最大连接数，maxThreads是指在该连接器可以创建的最大线程数。minSpareThreads是指保持活跃的最小线程数。

调优时，应根据应用需求、服务器硬件性能和负载情况进行具体调整。

PostgreSQL 常用监控指标

2024-09-05

在PostgreSQL中，监控关键性能指标可以帮助你识别和解决性能问题。以下是一些常用的监控指标：

数据库大小：使用pg_database_size()函数获取当前数据库的大小。
连接数：使用pg_stat_activity视图来查看当前连接数和活动连接数。
查询执行时间：使用pg_stat_statements扩展来监控查询的执行时间。
缓存命中率：通过pg_statio_user_tables视图可以查看缓存的命中和缺失情况。
锁等待：使用pg_stat_activity视图来查看哪些查询正在等待锁。
表的I/O统计：使用pg_stat_user_tables视图来查看表的I/O活动。
表空间使用情况：使用pg_tablespace_size()函数查看各表空间的使用情况。
超时配置：监控配置参数lock_timeout和idle_in_transaction_session_timeout来管理长事务和锁等待。

以下是一些SQL查询示例，用于检查上述指标：




-- 查询数据库大小
SELECT pg_size_pretty(pg_database_size('your_database_name'));
 
-- 查询当前连接数和活动连接数
SELECT COUNT(*) AS total_connections,
       COUNT(CASE WHEN state = 'active' THEN 1 END) AS active_connections
FROM pg_stat_activity;
 
-- 查询查询的执行时间
-- 需要启用pg_stat_statements扩展
SELECT query, calls, total_time, rows, 100.0 * shared_blks_hit / nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent
FROM pg_stat_statements
ORDER BY total_time DESC
LIMIT 10;
 
-- 查询缓存命中率
SELECT relname, heap_blks_read, heap_blks_hit, 100.0 * heap_blks_hit / (heap_blks_hit + heap_blks_read) AS cache_hit_percent
FROM pg_statio_user_tables
ORDER BY heap_blks_read + heap_blks_hit DESC
LIMIT 10;
 
-- 查询锁等待
SELECT pid, usename, datname, query, state, wait_event_type, wait_event
FROM pg_stat_activity
WHERE state = 'active' AND wait_event IS NOT NULL;
 
-- 查询表的I/O统计
SELECT relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del
FROM pg_stat_user_tables
ORDER BY n_tup_ins + n_tup_upd + n_tup_del DESC
LIMIT 10;
 
-- 查询表空间使用情况
SELECT spcname, pg_size_pretty(pg_tablespace_size(spcname)) AS size
FROM pg_tablespace;
 
-- 查询超时配置
SHOW lock_timeout;
SHOW idle_in_transaction_session_timeout;

这些查询可以帮助你了解数据库的当前状态，并且可以根据需要调整配置或优化查询来提高性能。