# SPeed-Tomcat 手写基于 Socket 的 Tomcat 服务器

**Repository Path**: tlgen_1/my-tomcat

## Basic Information

- **Project Name**: SPeed-Tomcat 手写基于 Socket 的 Tomcat 服务器
- **Description**: 1.基于 socket 封装
2.基于反射 + 注解实现目标方法调用
3.基于线程池处理请求任务
4.支持 GET，POST，PUT，DELETE 请求方式
5.支持 Spring 控制层请求注解
6.支持 @Filter 注解自定义请求拦截器
- **Primary Language**: Unknown
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2024-01-18
- **Last Updated**: 2025-04-14

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# SPeed-Tomcat 手写基于 Socket 的 Tomcat 服务器

#### 框架简介

1.基于 socket 封装实现请求响应;  
2.基于反射 + 注解的请求适配控制器;  
3.支持自定义端口, 支持 spring 风格配置化;  
4.支持自定义线程池处理请求, 支持 spring 风格配置化;   
5.支持控制层 Restful 注解声明调用 GET，POST，PUT，DELETE 请求;   
6.支持 @Filter 注解自定义请求拦截器;   
7.接口文档地址：https://apifox.com/apidoc/shared-169e65ce-d321-47bc-b606-b164d7bfb78d  

#### 快速上手

可以直接下载代码根目录下的 [speed-tomcat-0.0.1.jar](speed-tomcat-0.0.1.jar) 引入, 或本地 install 引入如下(未打入 Maven 中央仓库)

```ruby
        <dependency>
            <groupId>com.tlgen</groupId>
            <artifactId>speed-tomcat</artifactId>
            <version>0.0.1</version>
        </dependency>
```

#### 新建 Maven 项目

```ruby
tomcat-test ## 纯 Maven 项目
```
![1](doc/1.png)

##### 引入 speed-tomcat-0.0.1.jar 依赖
![2](doc/2.png)

##### main 方法入口
```ruby
调用 SpeedTomcatApplication.run(args); 方法
```

```ruby
import com.tlgen.tomcat.SpeedTomcatApplication;

public class Main {

    public static void main(String[] args) {
        SpeedTomcatApplication.run(args);
    }

}
```

##### main 方法启动
![3](doc/3.png)

##### 新建 controller 接口类

```ruby
package controller;

import annotation.com.tlgen.tomcat.GetMapping;
import annotation.com.tlgen.tomcat.RequestMapping;
import comon.com.tlgen.tomcat.R;

@RequestMapping("/my-test")
public class HelloController {

    @GetMapping("/hello")
    public R hello() {
        return R.ok("SUCCESS");
    }

}
```
##### 调用接口测试

```ruby
调用 http://localhost:8890/my-test/hello

返回: {"code":200,"data":"SUCCESS","msg":"操作成功!"}

```

#### Restful 接口使用示例

```ruby
接口文档地址：https://apifox.com/apidoc/shared-169e65ce-d321-47bc-b606-b164d7bfb78d  
```

##### GET 请求无 @RequestMapping
```ruby
package com.tlgen.controller;

import annotation.com.tlgen.tomcat.GetMapping;

public class TestController {

    @GetMapping("/test")
    public String test() {
        return "SUCCESS";
    }

}
```

##### GET 请求无参
```ruby
    @GetMapping("/hello")
    public Object hello() {
        return "hello world!";
    }
```

##### GET 请求带入参
```ruby
    @GetMapping("/selectList")
    public Object selectList(String username, String mobile, int status, boolean flag) {
        SysUserService sysUserService = () -> {
            List<SysUser> userList = Lists.newArrayList();
            SysUser user1 = SysUser.builder().username("11").mobile("136xx").email("11@qq.com").build();
            SysUser user2 = SysUser.builder().username("22").mobile("136xx").email("22@qq.com").build();
            SysUser user3 = SysUser.builder().username("33").mobile("136xx").email("33@qq.com").build();
            userList.add(user1);
            userList.add(user2);
            userList.add(user3);
            return userList;
        };
        List<SysUser> userList = sysUserService.selectList();
        return R.ok(userList, "查询用户数据列表成功!");
    }
```

##### GET 请求 @PathVariable 方式接收路径参数
```ruby
    @GetMapping("/select/{username}/{mobile}")
    public Object select(@PathVariable("username") String username, @PathVariable("mobile") String mobile) {
        return R.ok("查询成功!");
    }
```

##### POST 请求 @RequestBody 方式接收 JSON 参数
```ruby
    @PostMapping("/save")
    public Object save(@RequestBody SysUser user) {
        return R.ok("保存用户数据成功!");
    }
```

##### POST 请求 @RequestParam 方式接收 form-data 参数
```ruby
    @PostMapping("/saveBatch")
    public Object saveBatch(@RequestParam("username") String username,
                            @RequestParam("email") String email,
                            @RequestParam("status") Integer status) {
        return R.ok("批量保存用户数据成功!");
    }
```

##### POST 请求 @PathVariable 方式接收路径参数
```ruby
    @PostMapping("/saveUser/{username}/{email}")
    public Object saveUser(@PathVariable("username") String username, @PathVariable("email") String email) {
        return R.ok("saveUser 保存用户数据成功!");
    }
```

##### POST 请求 @RequestBody 方式接收 Map 接口类型参数
```ruby
    @PostMapping("/saveUserByMap")
    public Object saveUserByMap(@RequestBody Map<String, Object> map) {
        System.out.println(map);
        return "saveUserByMap 保存用户数据成功!";
    }
```

##### POST 请求 @RequestBody 方式接收 List 接口类型参数
```ruby
    @PostMapping("/saveUserByList")
    public Object saveUserByList(@RequestBody List<SysUser> userList) {
        System.out.println(userList);
        return "saveUserByList 保存用户数据成功!";
    }
```

##### POST 请求 @RequestBody 方式接收 Collection 接口类型参数
```ruby
    @PostMapping("/saveUserByCollection")
    public Object saveUserByCollection(@RequestBody Collection<SysUser> userList) {
        System.out.println(userList);
        return "saveUserByCollection 保存用户数据成功!";
    }
```

##### POST 请求 @RequestBody 方式接收 Object 类型参数
```ruby
    @PostMapping("/saveUserByObject")
    public Object saveUserByObject(@RequestBody Object object) {
        System.out.println(object);
        return "saveUserByObject 保存用户数据成功!";
    }
```

##### PUT 请求 @RequestBody 方式接收 JSON 参数
```ruby
    @PutMapping("/update")
    public Object update(@RequestBody SysUser user) {
        return R.ok("更新用户数据成功!");
    }
```

##### PUT 请求 @RequestParam 方式接收 form-data 参数
```ruby
    @PutMapping("/updateBatch")
    public Object updateBatch(@RequestParam("username") String username, @RequestParam("email") String email) {
        return R.ok("批量更新用户数据成功!");
    }
```

##### PUT 请求 @PathVariable 方式接收路径参数
```ruby
    @PutMapping("/updateUser/{username}/{email}")
    public Object updateUser(@PathVariable("username") String username, @PathVariable("email") String email) {
        return R.ok("updateUser 更新用户数据成功!");
    }
```

##### PUT 请求 @RequestBody 方式接收 Map 接口类型参数
```ruby
    @PutMapping("/updateUserByMap")
    public Object updateUserByMap(@RequestBody Map<String, Object> map) {
        System.out.println(map);
        return "updateUserByMap 更新用户数据成功!";
    }
```

##### DELETE 请求 @PathVariable 方式接收路径参数
```ruby
    @DeleteMapping("/delete/{username}/{mobile}")
    public Object delete(@PathVariable("username") String username, @PathVariable("mobile") String mobile) {
        return R.ok("删除成功!");
    }
```

##### DELETE 请求 @RequestBody 方式接收 JSON 参数
```ruby
    @DeleteMapping("/deleteBatch")
    public Object deleteBatch(@RequestBody SysUser user) {
        return R.ok("批量删除成功!");
    }
```

##### DELETE 请求 @RequestParam 方式接收 form-data 参数
```ruby
    @DeleteMapping("/deleteBatch2")
    public Object deleteBatch2(@RequestParam("username") String username, @RequestParam("email") String email) {
        return R.ok("批量删除成功2!");
    }
```

##### DELETE 请求 @RequestBody 方式接收 Map 接口类型参数
```ruby
    @DeleteMapping("/deleteUserByMap")
    public Object deleteUserByMap(@RequestBody Map<String, Object> map) {
        System.out.println(map);
        return "deleteUserByMap 删除用户数据成功!";
    }
```

#### 请求完整示例 (GET、POST、PUT、DELETE)
```ruby
package com.tlgen.controller;

import com.google.common.collect.Lists;
import com.tlgen.annotation.*;
import comon.com.tlgen.tomcat.R;
import model.com.tlgen.tomcat.SysUser;
import service.com.tlgen.tomcat.SysUserService;

import java.util.Collection;
import java.util.List;
import java.util.Map;

@RequestMapping("/user")
public class SysUserController {

    @GetMapping("/selectList")
    public Object selectList(String username, String mobile, int status, boolean flag) {
        SysUserService sysUserService = () -> {
            List<SysUser> userList = Lists.newArrayList();
            SysUser user1 = SysUser.builder().username("11").mobile("136xx").email("11@qq.com").build();
            SysUser user2 = SysUser.builder().username("22").mobile("136xx").email("22@qq.com").build();
            SysUser user3 = SysUser.builder().username("33").mobile("136xx").email("33@qq.com").build();
            userList.add(user1);
            userList.add(user2);
            userList.add(user3);
            return userList;
        };
        List<SysUser> userList = sysUserService.selectList();
        return R.ok(userList, "查询用户数据列表成功!");
    }

    @GetMapping("/select/{username}/{mobile}")
    public Object select(@PathVariable("username") String username, @PathVariable("mobile") String mobile) {
        return R.ok("查询成功!");
    }

    @PostMapping("/save")
    public Object save(@RequestBody SysUser user) {
        return R.ok("保存用户数据成功!");
    }

    @PostMapping("/saveBatch")
    public Object saveBatch(@RequestParam("username") String username,
                            @RequestParam("email") String email,
                            @RequestParam("status") Integer status) {
        return R.ok("批量保存用户数据成功!");
    }

    @PostMapping("/saveUser/{username}/{email}")
    public Object saveUser(@PathVariable("username") String username, @PathVariable("email") String email) {
        return R.ok("saveUser 保存用户数据成功!");
    }

    @PostMapping("/saveUserByMap")
    public Object saveUserByMap(@RequestBody Map<String, Object> map) {
        System.out.println(map);
        return "saveUserByMap 保存用户数据成功!";
    }

    @PostMapping("/saveUserByList")
    public Object saveUserByList(@RequestBody List<SysUser> userList) {
        System.out.println(userList);
        return "saveUserByList 保存用户数据成功!";
    }

    @PostMapping("/saveUserByCollection")
    public Object saveUserByCollection(@RequestBody Collection<SysUser> userList) {
        System.out.println(userList);
        return "saveUserByCollection 保存用户数据成功!";
    }

    @PostMapping("/saveUserByObject")
    public Object saveUserByObject(@RequestBody Object object) {
        System.out.println(object);
        return "saveUserByObject 保存用户数据成功!";
    }
    
    @PutMapping("/update")
    public Object update(@RequestBody SysUser user) {
        return R.ok("更新用户数据成功!");
    }

    @PutMapping("/updateBatch")
    public Object updateBatch(@RequestParam("username") String username, @RequestParam("email") String email) {
        return R.ok("批量更新用户数据成功!");
    }

    @PutMapping("/updateUser/{username}/{email}")
    public Object updateUser(@PathVariable("username") String username, @PathVariable("email") String email) {
        return R.ok("updateUser 更新用户数据成功!");
    }

    @PutMapping("/updateUserByMap")
    public Object updateUserByMap(@RequestBody Map<String, Object> map) {
        System.out.println(map);
        return "updateUserByMap 更新用户数据成功!";
    }

    @DeleteMapping("/delete/{username}/{mobile}")
    public Object delete(@PathVariable("username") String username, @PathVariable("mobile") String mobile) {
        return R.ok("删除成功!");
    }

    @DeleteMapping("/deleteBatch")
    public Object deleteBatch(@RequestBody SysUser user) {
        return R.ok("批量删除成功!");
    }

    @DeleteMapping("/deleteBatch2")
    public Object deleteBatch2(@RequestParam("username") String username, @RequestParam("email") String email) {
        return R.ok("批量删除成功2!");
    }

    @DeleteMapping("/deleteUserByMap")
    public Object deleteUserByMap(@RequestBody Map<String, Object> map) {
        System.out.println(map);
        return "deleteUserByMap 删除用户数据成功!";
    }

}

```