MyBatisPlus教程

编程语言 2023-06-24 20:49:34 阅读次数: 0

一、MyBatisPlus

KuangStudy

MyBatisPlus学习视频：狂神说MyBatisPlus教程

KuangStudy
https://www.kuangstudy.com/course

MyBatisPlus学习视频:
https://www.bilibili.com/video/BV17E411N7KN?p=1

MyBatisPlus官网：https://baomidou.com/

MyBatisPlus文档：https://baomidou.com/pages/24112f/

一、MyBatisPlus简介

一、MyBatisPlus简介

MyBatisPlus官网：https://baomidou.com/

MyBatisPlus文档：https://baomidou.com/pages/24112f/

1642410819954

二、特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
  • 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
  • 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
  • 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
  • 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
  • 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
  • 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
  • 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
  • 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
  • 内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
  • 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

二、快速入门

使用第三方插件:

  1. 导入对应的依赖
  2. 研究依赖如何配置
  3. 代码如何编写
  4. 提高扩展技术能力

1.创建数据库 mybatis_plus

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
	id BIGINT(20) NOT NULL COMMENT '主键ID',
	name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
	age INT(11) NULL DEFAULT NULL COMMENT '年龄',
	email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (id)
);
--真实开发环境中,version(乐观锁),deleted(逻辑删除),gmt_create,gmt_modified
DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

1642413075576

2、编写项目,使用SpringBoot初始化!

1642411303117

1642411321622

3、 导入依赖

注:我们使用mybatis-plus 可以节省我们大量的代码,尽量不要同时导入mybatis和mybatis-plus因为版本有差异!

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.Jin</groupId>
    <artifactId>mybatis_plus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis_plus</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
        <!--mybatis_plus是自己开发的，并非官方的-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!-- 代码生成器模板引擎 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>hu.blackbelt.bundles.swagger-parser</groupId>
            <artifactId>io.swagger.parser</artifactId>
            <version>1.0.47_1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

4、application.properties配置文件

#设置开发环境
spring.profiles.active=dev
#mysql 8
spring.datasource.username=root
spring.datasource.password=123456
#spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
#serverTimezone=Asia/Shanghai        serverTimezone=GMT%2B8
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#逻辑删除配置
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

5、编写pojo

package com.jin.pojo;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * @Package:com.jin.pojo
 * @ClassName: User
 * @Description:
 * @Date: 2021/12/06 17:12
 * @Author: Jin
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user")
public class User {
    
    
    /**
     * Auto	            数据库自增
     * Input	        自行输入
     * ID_Worker	    分布式全局唯一ID 长整型类型
     * UUID	3           2位UUID字符串、全局唯一id uuid
     * NONE	            无状态
     * ID_WORKER_STR	分布式全局唯一ID 字符串类型
     */
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;

    @Version//乐观锁Version注解
    private Integer version;

    @TableLogic//逻辑删除注解
    private Integer deleted;

    //字段添加填充内容
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

6、编写mapper

package com.jin.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jin.pojo.User;
import org.springframework.stereotype.Repository;

/**
 * @Package:com.jin.mapper
 * @ClassName: Usermapper
 * @Description:
 * @Date: 2021/12/06 17:14
 * @Author: Jin
 */
@Repository//代表持久层
//在mybatis_plus上面继承基本的类BaseMapper
public interface UserMapper extends BaseMapper<User> {
    
    

}

7、启动类配置

package com.jin;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//扫描mapper文件夹
@MapperScan("com.Jin.mapper")
@SpringBootApplication
public class MybatisPlusApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(MybatisPlusApplication.class, args);
    }

}

8、测试

package com.jin;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.jin.mapper.UserMapper;
import com.jin.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
class MybatisPlusApplicationTests {
    
    

    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
    
    
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
    
    
            System.out.println(user);
        }
        System.out.println();
        users.forEach(System.out::println);
    }
}

9、输出结果

1642411896677

三、配置日志

properties里配置日志

#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

四、MyMetaObjectHandler

package com.jin.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @Package:com.jin.handler
 * @ClassName: MyMetaObjectHandler
 * @Description:	处理器，自动填充插入和更新时间
 * @Date: 2021/12/07 9:20
 * @Author: Jin
 */
@Slf4j
@Component //把处理器加到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    
    
    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
    
    
        log.info("start insert fill...");
        //    default MetaObjectHandler setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject) {
    
    
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
    //更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
    
    
        log.info("start update fill...");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

五、MyBatisPlusConfig

package com.jin.config;

import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @Package:com.jin.config
 * @ClassName: MyBatisPlusConfig
 * @Description:
 * @Date: 2021/12/07 9:51
 * @Author: Jin
 */
//扫描我们的mapper文件夹
@MapperScan("com.Jin.mapper")
@EnableTransactionManagement
@Configuration               //配置类
public class MyBatisPlusConfig {
    
    
    /**
     * 旧版
     * //注册乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
    
    
        return new OptimisticLockerInterceptor();
    }
    /**
     * 旧版
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
    
    
        return new PaginationInterceptor();
    }
    /**
     * 旧版
     * 逻辑删除组件
     */
    @Bean
    public ISqlInjector sqlInjector(){
    
    
        return new LogicSqlInjector();
    }
    /**
     * 性能分析插件
     */
    @Bean
    @Profile({
    
    "dev","test"}) //设置dev 和 test环境开启,保障开发效率
    public PerformanceInterceptor performanceInterceptor(){
    
    
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        //设置sql执行的最大时间，如果超过就不执行（报错，提示sql执行时间too large），不允许用户等待
        performanceInterceptor.setMaxTime(200);
        //是否格式化代码
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }
}

六、MybatisPlusApplicationTests

package com.jin;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.jin.mapper.UserMapper;
import com.jin.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
class MybatisPlusApplicationTests {
    
    

    @Autowired
    private UserMapper userMapper;
	//查询所有数据
    @Test
    void contextLoads() {
    
    
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
    
    
            System.out.println(user);
        }
        System.out.println();
        users.forEach(System.out::println);
    }
    //测试插入
    @Test
    public void insert(){
    
    
        User user = new User();
        user.setName("Yangon");
        user.setAge(11);
        user.setEmail("[email protected]");
        int insert = userMapper.insert(user);
        System.out.println(insert);
        System.out.println(user);
    }
    //测试更新
    @Test
    public void update(){
    
    
        User user = new User();
        user.setId(1L);
        user.setName("JiWu");
        user.setAge(99);
        int i = userMapper.updateById(user);
        System.out.println(i);
        System.out.println(user);
    }
    //测试乐观锁成功！
    @Test
    public void testOptimisticLocker(){
    
    
        //1、查询用户信息
        User user = userMapper.selectById(1L);
        System.out.println(user);
        //2、修改用户信息
        user.setName("Nameddd");
        user.setEmail("[email protected]");
        //3、执行更新操作
        userMapper.updateById(user);
    }
    //测试乐观锁失败！多线程下
    @Test
    public void testOptimisticLocker2(){
    
    
        //线程1
        User user = userMapper.selectById(1L);
        System.out.println(user);
        user.setName("Nameddd");
        user.setEmail("[email protected]");
        //模拟另外一个线程执行了插队操作
        User user2 = userMapper.selectById(1L);
        System.out.println(user);
        user2.setName("Nameddd2222");
        user2.setEmail("[email protected]");
        userMapper.updateById(user2);
        //自旋锁来多次尝试提交！
        userMapper.updateById(user);//如果没有乐观锁就会覆盖插队线程的值！
    }

    //测试按id查询
    @Test
    public void testSelectById(){
    
    
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
    //测试按批量查询
    @Test
    public void testSelectBatchId(){
    
    
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        System.out.println(users);
        System.out.println();
        users.forEach(System.out::println);
    }

    //测试按条件map查询
    @Test
    public void testSelectByMap(){
    
    
        HashMap<String, Object> map = new HashMap<>();
        //自定义查询
        map.put("name","JiWu");
        map.put("email","[email protected]");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

    //测试分页查询
    @Test
    public void testPage(){
    
    
        //参数一：当前页
        //参数二：页面大小
        Page<User> page = new Page<>(2,5);
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

    //测试根据id删除记录
    @Test
    public void testDeleteById(){
    
    
        int i = userMapper.deleteById(1L);
        System.out.println(i);
    }
    //测试根据id批量删除记录
    @Test
    public void testDeleteBatchIds(){
    
    
        int i = userMapper.deleteBatchIds(Arrays.asList(1467789606408249346L, 1467789606408249347L, 1467789606408249348L, 1467789606408249349L));
        System.out.println(i);
    }
    //测试通过Map删除记录
    @Test
    public void testDeleteByMap(){
    
    
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",1467789606408249351L);
        int i = userMapper.deleteByMap(map);
        System.out.println(i);
    }
}

七、WrapperTest

package com.jin;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jin.mapper.UserMapper;
import com.jin.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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

/**
 * @Package:com.jin
 * @ClassName: WrapperTest
 * @Description:
 * @Date: 2021/12/07 15:16
 * @Author: Jin
 */
@SpringBootTest
public class WrapperTest {
    
    
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
    
    
        //查询name！=null和并且邮箱不为空的用户，年龄大于等于12
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
            .isNotNull("name")
            .isNotNull("email")
            .ge("age",12);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }
    @Test
    void test2(){
    
    
        //查询名字JiWu
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //查询一个数据，出现多个结果使用List或者Map
        wrapper.eq("name","Tom");
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }
    @Test
    void test3(){
    
    
        //查询年龄在20~30岁之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30);
        Integer count = userMapper.selectCount(wrapper);
        System.out.println(count);
    }
    @Test
    void test4(){
    
    
        //查询名字里面不包含Ji
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("name","Ji")
            .likeRight("email","t");
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }
    @Test
    void test5(){
    
    
        //查询联表
        //id在子查询中查出来
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.inSql("id","select id from user where id<3");
        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }
    @Test
    void test6(){
    
    
        //查询通过id进行排序
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("id");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
}

1644330566760

八、代码生成器

package com.jin;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.ArrayList;

/**
 * @Package:com.jin
 * @ClassName: JinCode
 * @Description:代码自动生成器
 * @Date: 2021/12/07 16:17
 * @Author: Jin
 */
// 代码自动生成器
public class JinCode {
    
    
    public static void main(String[] args) {
    
    
        // 需要构建一个 代码自动生成器 对象
        AutoGenerator mpg = new AutoGenerator();

        // 配置策略
        // 1、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath+"/src/main/java");
        gc.setAuthor("Jin"); gc.setOpen(false);
        gc.setFileOverride(false);

        // 是否覆盖
        gc.setServiceName("%sService");

        // 去Service的I前缀
        gc.setIdType(IdType.ID_WORKER);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);

        //2、设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/test? useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        dsc.setDbType(DbType.MYSQL); mpg.setDataSource(dsc);

        //3、包的配置
        PackageConfig pc = new PackageConfig();
        //只需要改实体类名字 和包名 还有 数据库配置即可
        pc.setModuleName("blog"); pc.setParent("com.Jin");
        pc.setEntity("entity"); pc.setMapper("mapper");
        pc.setService("service"); pc.setController("controller");
        mpg.setPackageInfo(pc);

        //4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("account","emp","dept");

        // 设置要映射的表名
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);

        // 自动lombok；
        strategy.setLogicDeleteFieldName("deleted");

        // 自动填充配置
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate); tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills);

        // 乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);

        // localhost:8080/hello_id_2
        mpg.setStrategy(strategy);
        mpg.execute(); //执行
    }
}

输出结果

1642412681888

猜你喜欢

转载自blog.csdn.net/weixin_45207323/article/details/129671925
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022