• Docker 容器编排

    是什么

            Docker-Compose是 Docker 官方的开源项目，负责实现对Docker容器集群的快速编排。

            Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器。

    能干嘛

            docker建议我们每一个容器中只运行一个服务，因为docker容器本身占用资源极少，所以最好是将每个服务单独的分割开来但是这样我们又面临了一个问题？

            如果我需要同时部署好多个服务，难道要每个服务单独写Dockerfile然后在构建镜像，构建容器，这样累都累死了，所以docker官方给我们提供了docker-compose多服务部署的工具。

            例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。

            Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。

            可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。

    去哪下

    官网：Compose file version 3 reference | Docker Docs

    官网下载：Overview of installing Docker Compose | Docker Docs

    安装步骤：

    1、验证网络并下载

            curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

    2、给文件赋权限

            chmod +x /usr/local/bin/docker-compose

    3、查看安装版本号

            docker-compose --version

    卸载步骤：

    Compose核心概念

    一个文件：docker-compose.yml

    两个要素：

            1、服务(service)：一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器。

            2、工程(project)：由一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml文件中定义。

    Compose使用的三个步骤

    1、编写Dockerfile定义各个微服务应用并构建出对应的镜像文件。

    2、使用docker-compose.yml，定义一个完整业务单元，安排好整体应用中的各个容器服务。

    3、最后，执行docker-compose up命令，来启动并运行整个应用程序，完成一键部署上线。（加参数-d表示后台静默执行）

    Compose常用命令

    docker-compose -h                                              # 查看帮助

    docker-compose up                                             # 启动所有docker-compose服务

    docker-compose up -d                                         # 启动所有docker-compose服务并后台运行

    docker-compose down                                         # 停止并删除容器、网络、卷、镜像。

    docker-compose exec  yml里面的服务id             # 进入容器实例内部  docker-compose exec docker-compose.yml 文件中写的服务id /bin/bash

    docker-compose ps                               # 展示当前docker-compose编排过的运行的所有容器

    docker-compose top                              # 展示当前docker-compose编排过的容器进程

    docker-compose logs  yml里面的服务id              # 查看容器输出日志

    docker-compose config                                       # 检查配置

    docker-compose config -q                                   # 检查配置，有问题才有输出

    docker-compose restart                                       # 重启服务

    docker-compose start                                          # 启动服务

    docker-compose stop                                          # 停止服务

    Compose编排微服务

    创建微服务项目

    1、建表语句

    CREATE TABLE `t_user` (

      `id` int(10) unsigned NOT NULL AUTO_INCREMENT,

      `username` varchar(50) NOT NULL DEFAULT '' COMMENT '用户名',

      `password` varchar(50) NOT NULL DEFAULT '' COMMENT '密码',

      `sex` tinyint(4) NOT NULL DEFAULT '0' COMMENT '性别 0=女 1=男 ',

      `deleted` tinyint(4) unsigned NOT NULL DEFAULT '0' COMMENT '删除标志，默认0不删除，1删除',

      `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',

      `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',

      PRIMARY KEY (`id`)

    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='用户表'；

    2、建module，服务工程如下：

    3、pom文件

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <parent>
    6.         <groupId>org.springframework.bootgroupId>
    7.         <artifactId>spring-boot-starter-parentartifactId>
    8.         <version>2.5.6version>
    9.         
    10.         <relativePath/> 
    11.     parent>
    12.  
    13.     <groupId>com.atguigu.dockergroupId>
    14.     <artifactId>docker_bootartifactId>
    15.     <version>0.0.1-SNAPSHOTversion>
    16.  
    17.     <properties>
    18.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    19.         <maven.compiler.source>1.8maven.compiler.source>
    20.         <maven.compiler.target>1.8maven.compiler.target>
    21.         <junit.version>4.12junit.version>
    22.         <log4j.version>1.2.17log4j.version>
    23.         <lombok.version>1.16.18lombok.version>
    24.         <mysql.version>5.1.47mysql.version>
    25.         <druid.version>1.1.16druid.version>
    26.         <mapper.version>4.1.5mapper.version>
    27.         <mybatis.spring.boot.version>1.3.0mybatis.spring.boot.version>
    28.     properties>
    29.  
    30.     <dependencies>
    31.         
    32.         <dependency>
    33.             <groupId>com.google.guavagroupId>
    34.             <artifactId>guavaartifactId>
    35.             <version>23.0version>
    36.         dependency>
    37.         
    38.         <dependency>
    39.             <groupId>org.redissongroupId>
    40.             <artifactId>redissonartifactId>
    41.             <version>3.13.4version>
    42.         dependency>
    43.         
    44.         <dependency>
    45.             <groupId>org.springframework.bootgroupId>
    46.             <artifactId>spring-boot-starter-webartifactId>
    47.         dependency>
    48.         
    49.         <dependency>
    50.             <groupId>io.springfoxgroupId>
    51.             <artifactId>springfox-swagger2artifactId>
    52.             <version>2.9.2version>
    53.         dependency>
    54.         <dependency>
    55.             <groupId>io.springfoxgroupId>
    56.             <artifactId>springfox-swagger-uiartifactId>
    57.             <version>2.9.2version>
    58.         dependency>
    59.         
    60.         <dependency>
    61.             <groupId>org.springframework.bootgroupId>
    62.             <artifactId>spring-boot-starter-data-redisartifactId>
    63.         dependency>
    64.         
    65.         <dependency>
    66.             <groupId>org.springframework.bootgroupId>
    67.             <artifactId>spring-boot-starter-cacheartifactId>
    68.         dependency>
    69.         
    70.         <dependency>
    71.             <groupId>org.apache.commonsgroupId>
    72.             <artifactId>commons-pool2artifactId>
    73.         dependency>
    74.         
    75.         <dependency>
    76.             <groupId>redis.clientsgroupId>
    77.             <artifactId>jedisartifactId>
    78.             <version>3.1.0version>
    79.         dependency>
    80.         
    81.         <dependency>
    82.             <groupId>mysqlgroupId>
    83.             <artifactId>mysql-connector-javaartifactId>
    84.             <version>5.1.47version>
    85.         dependency>
    86.         
    87.         <dependency>
    88.             <groupId>com.alibabagroupId>
    89.             <artifactId>druid-spring-boot-starterartifactId>
    90.             <version>1.1.10version>
    91.         dependency>
    92.         <dependency>
    93.             <groupId>com.alibabagroupId>
    94.             <artifactId>druidartifactId>
    95.             <version>${druid.version}version>
    96.         dependency>
    97.         
    98.         <dependency>
    99.             <groupId>org.mybatis.spring.bootgroupId>
    100.             <artifactId>mybatis-spring-boot-starterartifactId>
    101.             <version>${mybatis.spring.boot.version}version>
    102.         dependency>
    103.         
    104.         <dependency>
    105.             <groupId>org.springframework.bootgroupId>
    106.             <artifactId>spring-boot-starter-amqpartifactId>
    107.         dependency>
    108.         <dependency>
    109.             <groupId>commons-codecgroupId>
    110.             <artifactId>commons-codecartifactId>
    111.             <version>1.10version>
    112.         dependency>
    113.         
    114.         
    115.         <dependency>
    116.             <groupId>cn.hutoolgroupId>
    117.             <artifactId>hutool-allartifactId>
    118.             <version>5.2.3version>
    119.         dependency>
    120.         <dependency>
    121.             <groupId>junitgroupId>
    122.             <artifactId>junitartifactId>
    123.             <version>${junit.version}version>
    124.         dependency>
    125.         <dependency>
    126.             <groupId>org.springframework.bootgroupId>
    127.             <artifactId>spring-boot-devtoolsartifactId>
    128.             <scope>runtimescope>
    129.             <optional>trueoptional>
    130.         dependency>
    131.         <dependency>
    132.             <groupId>org.springframework.bootgroupId>
    133.             <artifactId>spring-boot-starter-testartifactId>
    134.             <scope>testscope>
    135.         dependency>
    136.         <dependency>
    137.             <groupId>log4jgroupId>
    138.             <artifactId>log4jartifactId>
    139.             <version>${log4j.version}version>
    140.         dependency>
    141.         <dependency>
    142.             <groupId>org.projectlombokgroupId>
    143.             <artifactId>lombokartifactId>
    144.             <version>${lombok.version}version>
    145.             <optional>trueoptional>
    146.         dependency>
    147.         
    148.         <dependency>
    149.             <groupId>javax.persistencegroupId>
    150.             <artifactId>persistence-apiartifactId>
    151.             <version>1.0.2version>
    152.         dependency>
    153.         
    154.         <dependency>
    155.             <groupId>tk.mybatisgroupId>
    156.             <artifactId>mapperartifactId>
    157.             <version>${mapper.version}version>
    158.         dependency>
    159.     dependencies>
    160.  
    161.     <build>
    162.         <plugins>
    163.             <plugin>
    164.                 <groupId>org.springframework.bootgroupId>
    165.                 <artifactId>spring-boot-maven-pluginartifactId>
    166.             plugin>
    167.             <plugin>
    168.                 <groupId>org.apache.maven.pluginsgroupId>
    169.                 <artifactId>maven-resources-pluginartifactId>
    170.                 <version>3.1.0version>
    171.             plugin>
    172.         plugins>
    173.     build>
    174.  
    175. project>

    4、yaml文件(这里的mysql和redis使用redis中的服务名、通过服务名访问，IP无关)

    server.port=6001
    # ========================alibaba.druid相关配置=====================
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://mysql:3306/db2021?useUnicode=true&characterEncoding=utf-8&useSSL=false
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.druid.test-while-idle=false
    # ========================redis相关配置=====================
    spring.redis.database=0
    spring.redis.host=redis
    spring.redis.port=6379
    spring.redis.password=
    spring.redis.lettuce.pool.max-active=8
    spring.redis.lettuce.pool.max-wait=-1ms
    spring.redis.lettuce.pool.max-idle=8
    spring.redis.lettuce.pool.min-idle=0
    # ========================mybatis相关配置===================
    mybatis.mapper-locations=classpath:mapper/*.xml
    mybatis.type-aliases-package=com.atguigu.docker.entities
    # ========================swagger=====================
    spring.swagger2.enabled=true

    5、主启动文件

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import tk.mybatis.spring.annotation.MapperScan;
    4.  
    5. @SpringBootApplication
    6. @MapperScan("com.atguigu.docker.mapper") //import tk.mybatis.spring.annotation.MapperScan;
    7. public class DockerBootApplication {
    8.     public static void main(String[] args) {
    9.         SpringApplication.run(DockerBootApplication.class, args);
    10.     }
    11. }

    6、配置文件

    1. import lombok.extern.slf4j.Slf4j;
    2. import org.springframework.context.annotation.Bean;
    3. import org.springframework.context.annotation.Configuration;
    4. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    5. import org.springframework.data.redis.core.RedisTemplate;
    6. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    7. import org.springframework.data.redis.serializer.StringRedisSerializer;
    8.  
    9. import java.io.Serializable;
    10.  
    11. @Configuration
    12. @Slf4j
    13. public class RedisConfig {
    14.     /**
    15.      * @param lettuceConnectionFactory
    16.      * @return
    17.      *
    18.      * redis序列化的工具配置类，下面这个请一定开启配置
    19.      * 127.0.0.1:6379> keys *
    20.      * 1) "ord:102"  序列化过
    21.      * 2) "\xac\xed\x00\x05t\x00\aord:102"   野生，没有序列化过
    22.      */
    23.     @Bean
    24.     public RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
    25.         RedisTemplate redisTemplate = new RedisTemplate<>();
    26.  
    27.         redisTemplate.setConnectionFactory(lettuceConnectionFactory);
    28.         //设置key序列化方式string
    29.         redisTemplate.setKeySerializer(new StringRedisSerializer());
    30.         //设置value的序列化方式json
    31.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    32.  
    33.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    34.         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    35.  
    36.         redisTemplate.afterPropertiesSet();
    37.  
    38.         return redisTemplate;
    39.     }
    40.  
    41. }
    1. import org.springframework.beans.factory.annotation.Value;
    2. import org.springframework.context.annotation.Bean;
    3. import org.springframework.context.annotation.Configuration;
    4. import springfox.documentation.builders.ApiInfoBuilder;
    5. import springfox.documentation.builders.PathSelectors;
    6. import springfox.documentation.builders.RequestHandlerSelectors;
    7. import springfox.documentation.service.ApiInfo;
    8. import springfox.documentation.spi.DocumentationType;
    9. import springfox.documentation.spring.web.plugins.Docket;
    10. import springfox.documentation.swagger2.annotations.EnableSwagger2;
    11. import java.text.SimpleDateFormat;
    12. import java.util.Date;
    13.  
    14. @Configuration
    15. @EnableSwagger2
    16. public class SwaggerConfig {
    17.     @Value("${spring.swagger2.enabled}")
    18.     private Boolean enabled;
    19.  
    20.     @Bean
    21.     public Docket createRestApi() {
    22.         return new Docket(DocumentationType.SWAGGER_2)
    23.                 .apiInfo(apiInfo())
    24.                 .enable(enabled)
    25.                 .select()
    26.                 .apis(RequestHandlerSelectors.basePackage("com.atguigu.docker")) //你自己的package
    27.                 .paths(PathSelectors.any())
    28.                 .build();
    29.     }
    30.  
    31.     public ApiInfo apiInfo() {
    32.         return new ApiInfoBuilder()
    33.                 .title("尚硅谷Java大厂技术"+"\t"+new SimpleDateFormat("yyyy-MM-dd").format(new Date()))
    34.                 .description("docker-compose")
    35.                 .version("1.0")
    36.                 .termsOfServiceUrl("https://www.atguigu.com/")
    37.                 .build();
    38.     }
    39. }

    7、entity-mapper-service-contrller文件

    1. import javax.persistence.Column;
    2. import javax.persistence.GeneratedValue;
    3. import javax.persistence.Id;
    4. import javax.persistence.Table;
    5. import java.util.Date;
    6.  
    7. @Table(name = "t_user")
    8. public class User {
    9.     @Id
    10.     @GeneratedValue(generator = "JDBC")
    11.     private Integer id;
    12.  
    13.     /**
    14.      * 用户名
    15.      */
    16.     private String username;
    17.  
    18.     /**
    19.      * 密码
    20.      */
    21.     private String password;
    22.  
    23.     /**
    24.      * 性别 0=女 1=男 
    25.      */
    26.     private Byte sex;
    27.  
    28.     /**
    29.      * 删除标志，默认0不删除，1删除
    30.      */
    31.     private Byte deleted;
    32.  
    33.     /**
    34.      * 更新时间
    35.      */
    36.     @Column(name = "update_time")
    37.     private Date updateTime;
    38.  
    39.     /**
    40.      * 创建时间
    41.      */
    42.     @Column(name = "create_time")
    43.     private Date createTime;
    44.  
    45.     /**
    46.      * @return id
    47.      */
    48.     public Integer getId() {
    49.         return id;
    50.     }
    51.  
    52.     /**
    53.      * @param id
    54.      */
    55.     public void setId(Integer id) {
    56.         this.id = id;
    57.     }
    58.  
    59.     /**
    60.      * 获取用户名
    61.      *
    62.      * @return username - 用户名
    63.      */
    64.     public String getUsername() {
    65.         return username;
    66.     }
    67.  
    68.     /**
    69.      * 设置用户名
    70.      *
    71.      * @param username 用户名
    72.      */
    73.     public void setUsername(String username) {
    74.         this.username = username;
    75.     }
    76.  
    77.     /**
    78.      * 获取密码
    79.      *
    80.      * @return password - 密码
    81.      */
    82.     public String getPassword() {
    83.         return password;
    84.     }
    85.  
    86.     /**
    87.      * 设置密码
    88.      *
    89.      * @param password 密码
    90.      */
    91.     public void setPassword(String password) {
    92.         this.password = password;
    93.     }
    94.  
    95.     /**
    96.      * 获取性别 0=女 1=男 
    97.      *
    98.      * @return sex - 性别 0=女 1=男 
    99.      */
    100.     public Byte getSex() {
    101.         return sex;
    102.     }
    103.  
    104.     /**
    105.      * 设置性别 0=女 1=男 
    106.      *
    107.      * @param sex 性别 0=女 1=男 
    108.      */
    109.     public void setSex(Byte sex) {
    110.         this.sex = sex;
    111.     }
    112.  
    113.     /**
    114.      * 获取删除标志，默认0不删除，1删除
    115.      *
    116.      * @return deleted - 删除标志，默认0不删除，1删除
    117.      */
    118.     public Byte getDeleted() {
    119.         return deleted;
    120.     }
    121.  
    122.     /**
    123.      * 设置删除标志，默认0不删除，1删除
    124.      *
    125.      * @param deleted 删除标志，默认0不删除，1删除
    126.      */
    127.     public void setDeleted(Byte deleted) {
    128.         this.deleted = deleted;
    129.     }
    130.  
    131.     /**
    132.      * 获取更新时间
    133.      *
    134.      * @return update_time - 更新时间
    135.      */
    136.     public Date getUpdateTime() {
    137.         return updateTime;
    138.     }
    139.  
    140.     /**
    141.      * 设置更新时间
    142.      *
    143.      * @param updateTime 更新时间
    144.      */
    145.     public void setUpdateTime(Date updateTime) {
    146.         this.updateTime = updateTime;
    147.     }
    148.  
    149.     /**
    150.      * 获取创建时间
    151.      *
    152.      * @return create_time - 创建时间
    153.      */
    154.     public Date getCreateTime() {
    155.         return createTime;
    156.     }
    157.  
    158.     /**
    159.      * 设置创建时间
    160.      *
    161.      * @param createTime 创建时间
    162.      */
    163.     public void setCreateTime(Date createTime) {
    164.         this.createTime = createTime;
    165.     }
    166. }
    1. import io.swagger.annotations.ApiModel;
    2. import io.swagger.annotations.ApiModelProperty;
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import java.io.Serializable;
    8. import java.util.Date;
    9.  
    10. @NoArgsConstructor
    11. @AllArgsConstructor
    12. @Data
    13. @ApiModel(value = "用户信息")
    14. public class UserDTO implements Serializable {
    15.     @ApiModelProperty(value = "用户ID")
    16.     private Integer id;
    17.  
    18.     @ApiModelProperty(value = "用户名")
    19.     private String username;
    20.  
    21.     @ApiModelProperty(value = "密码")
    22.     private String password;
    23.  
    24.     @ApiModelProperty(value = "性别 0=女 1=男 ")
    25.     private Byte sex;
    26.  
    27.     @ApiModelProperty(value = "删除标志，默认0不删除，1删除")
    28.     private Byte deleted;
    29.  
    30.     @ApiModelProperty(value = "更新时间")
    31.     private Date updateTime;
    32.  
    33.     @ApiModelProperty(value = "创建时间")
    34.     private Date createTime;
    35.  
    36.     /**
    37.      * @return id
    38.      */
    39.     public Integer getId() {
    40.         return id;
    41.     }
    42.  
    43.     /**
    44.      * @param id
    45.      */
    46.     public void setId(Integer id) {
    47.         this.id = id;
    48.     }
    49.  
    50.     /**
    51.      * 获取用户名
    52.      *
    53.      * @return username - 用户名
    54.      */
    55.     public String getUsername() {
    56.         return username;
    57.     }
    58.  
    59.     /**
    60.      * 设置用户名
    61.      *
    62.      * @param username 用户名
    63.      */
    64.     public void setUsername(String username) {
    65.         this.username = username;
    66.     }
    67.  
    68.     /**
    69.      * 获取密码
    70.      *
    71.      * @return password - 密码
    72.      */
    73.     public String getPassword() {
    74.         return password;
    75.     }
    76.  
    77.     /**
    78.      * 设置密码
    79.      *
    80.      * @param password 密码
    81.      */
    82.     public void setPassword(String password) {
    83.         this.password = password;
    84.     }
    85.  
    86.     /**
    87.      * 获取性别 0=女 1=男 
    88.      *
    89.      * @return sex - 性别 0=女 1=男 
    90.      */
    91.     public Byte getSex() {
    92.         return sex;
    93.     }
    94.  
    95.     /**
    96.      * 设置性别 0=女 1=男 
    97.      *
    98.      * @param sex 性别 0=女 1=男 
    99.      */
    100.     public void setSex(Byte sex) {
    101.         this.sex = sex;
    102.     }
    103.  
    104.     /**
    105.      * 获取删除标志，默认0不删除，1删除
    106.      *
    107.      * @return deleted - 删除标志，默认0不删除，1删除
    108.      */
    109.     public Byte getDeleted() {
    110.         return deleted;
    111.     }
    112.  
    113.     /**
    114.      * 设置删除标志，默认0不删除，1删除
    115.      *
    116.      * @param deleted 删除标志，默认0不删除，1删除
    117.      */
    118.     public void setDeleted(Byte deleted) {
    119.         this.deleted = deleted;
    120.     }
    121.  
    122.     /**
    123.      * 获取更新时间
    124.      *
    125.      * @return update_time - 更新时间
    126.      */
    127.     public Date getUpdateTime() {
    128.         return updateTime;
    129.     }
    130.  
    131.     /**
    132.      * 设置更新时间
    133.      *
    134.      * @param updateTime 更新时间
    135.      */
    136.     public void setUpdateTime(Date updateTime) {
    137.         this.updateTime = updateTime;
    138.     }
    139.  
    140.     /**
    141.      * 获取创建时间
    142.      *
    143.      * @return create_time - 创建时间
    144.      */
    145.     public Date getCreateTime() {
    146.         return createTime;
    147.     }
    148.  
    149.     /**
    150.      * 设置创建时间
    151.      *
    152.      * @param createTime 创建时间
    153.      */
    154.     public void setCreateTime(Date createTime) {
    155.         this.createTime = createTime;
    156.     }
    157.  
    158.     @Override
    159.     public String toString() {
    160.         return "User{" +
    161.                 "id=" + id +
    162.                 ", username='" + username + '\'' +
    163.                 ", password='" + password + '\'' +
    164.                 ", sex=" + sex +
    165.                 '}';
    166.     }
    167. }
    1. import com.atguigu.docker.entities.User;
    2. import tk.mybatis.mapper.common.Mapper;
    3.  
    4. public interface UserMapper extends Mapper {
    5. }
    1. "1.0" encoding="UTF-8"?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3. <mapper namespace="com.atguigu.docker.mapper.UserMapper">
    4.   <resultMap id="BaseResultMap" type="com.atguigu.docker.entities.User">
    5.     
    6.     <id column="id" jdbcType="INTEGER" property="id" />
    7.     <result column="username" jdbcType="VARCHAR" property="username" />
    8.     <result column="password" jdbcType="VARCHAR" property="password" />
    9.     <result column="sex" jdbcType="TINYINT" property="sex" />
    10.     <result column="deleted" jdbcType="TINYINT" property="deleted" />
    11.     <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
    12.     <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
    13.   resultMap>
    14. mapper>
    1. import com.atguigu.docker.entities.User;
    2. import com.atguigu.docker.mapper.UserMapper;
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.slf4j.Logger;
    5. import org.slf4j.LoggerFactory;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.data.redis.core.RedisTemplate;
    8. import org.springframework.data.redis.core.ValueOperations;
    9. import org.springframework.stereotype.Service;
    10. import org.springframework.web.bind.annotation.PathVariable;
    11.  
    12. import javax.annotation.Resource;
    13. import java.util.concurrent.TimeUnit;
    14.  
    15. @Service
    16. @Slf4j
    17. public class UserService {
    18.  
    19.     public static final String CACHE_KEY_USER = "user:";
    20.  
    21.     @Resource
    22.     private UserMapper userMapper;
    23.     @Resource
    24.     private RedisTemplate redisTemplate;
    25.  
    26.     /**
    27.      * addUser
    28.      * @param user
    29.      */
    30.     public void addUser(User user)
    31.     {
    32.         //1 先插入mysql并成功
    33.         int i = userMapper.insertSelective(user);
    34.  
    35.         if(i > 0)
    36.         {
    37.             //2 需要再次查询一下mysql将数据捞回来并ok
    38.             user = userMapper.selectByPrimaryKey(user.getId());
    39.             //3 将捞出来的user存进redis，完成新增功能的数据一致性。
    40.             String key = CACHE_KEY_USER+user.getId();
    41.             redisTemplate.opsForValue().set(key,user);
    42.         }
    43.     }
    44.  
    45.     /**
    46.      * findUserById
    47.      * @param id
    48.      * @return
    49.      */
    50.     public User findUserById(Integer id)
    51.     {
    52.         User user = null;
    53.         String key = CACHE_KEY_USER+id;
    54.  
    55.         //1 先从redis里面查询，如果有直接返回结果，如果没有再去查询mysql
    56.         user = (User) redisTemplate.opsForValue().get(key);
    57.  
    58.         if(user == null)
    59.         {
    60.             //2 redis里面无，继续查询mysql
    61.             user = userMapper.selectByPrimaryKey(id);
    62.             if(user == null)
    63.             {
    64.                 //3.1 redis+mysql 都无数据
    65.                 //你具体细化，防止多次穿透，我们规定，记录下导致穿透的这个key回写redis
    66.                 return user;
    67.             }else{
    68.                 //3.2 mysql有，需要将数据写回redis，保证下一次的缓存命中率
    69.                 redisTemplate.opsForValue().set(key,user);
    70.             }
    71.         }
    72.         return user;
    73.     }
    74. }
    1. import cn.hutool.core.util.IdUtil;
    2. import cn.hutool.core.util.ReferenceUtil;
    3. import com.atguigu.docker.entities.User;
    4. import com.atguigu.docker.entities.UserDTO;
    5. import com.atguigu.docker.service.UserService;
    6. import io.swagger.annotations.Api;
    7. import io.swagger.annotations.ApiOperation;
    8. import io.swagger.models.auth.In;
    9. import lombok.extern.slf4j.Slf4j;
    10. import org.springframework.beans.BeanUtils;
    11. import org.springframework.beans.factory.annotation.Autowired;
    12. import org.springframework.web.bind.annotation.*;
    13.  
    14. import javax.annotation.Resource;
    15. import java.util.Random;
    16.  
    17. /**
    18.  * @auther zzyy
    19.  * @create 2021-05-01 15:02
    20.  */
    21. @Api(description = "用户User接口")
    22. @RestController
    23. @Slf4j
    24. public class UserController {
    25.     @Resource
    26.     private UserService userService;
    27.  
    28.     @ApiOperation("数据库新增3条记录")
    29.     @RequestMapping(value = "/user/add",method = RequestMethod.POST)
    30.     public void addUser()
    31.     {
    32.         for (int i = 1; i <=3; i++) {
    33.             User user = new User();
    34.  
    35.             user.setUsername("zzyy"+i);
    36.             user.setPassword(IdUtil.simpleUUID().substring(0,6));
    37.             user.setSex((byte) new Random().nextInt(2));
    38.  
    39.             userService.addUser(user);
    40.         }
    41.     }
    42.  
    43.     @ApiOperation("删除1条记录")
    44.     @RequestMapping(value = "/user/delete/{id}",method = RequestMethod.POST)
    45.     public void deleteUser(@PathVariable Integer id)
    46.     {
    47.         userService.deleteUser(id);
    48.     }
    49.  
    50.     @ApiOperation("修改1条记录")
    51.     @RequestMapping(value = "/user/update",method = RequestMethod.POST)
    52.     public void updateUser(@RequestBody UserDTO userDTO)
    53.     {
    54.         User user = new User();
    55.         BeanUtils.copyProperties(userDTO,user);
    56.         userService.updateUser(user);
    57.     }
    58.  
    59.     @ApiOperation("查询1条记录")
    60.     @RequestMapping(value = "/user/find/{id}",method = RequestMethod.GET)
    61.     public User findUserById(@PathVariable Integer id)
    62.     {
    63.         return userService.findUserById2(id);
    64.     }
    65. }

    8、mvn package命令将微服务形成新的jar包并上传到Linux服务器/mydocker目录下

    构建微服务镜像

    1、编写Dockerfile

    # 基础镜像使用java

    FROM java:8

    # 作者

    MAINTAINER zzyy

    # VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp

    VOLUME /tmp

    # 将jar包添加到容器中并更名为zzyy_docker.jar

    ADD docker_boot-0.0.1-SNAPSHOT.jar zzyy_docker.jar

    # 运行jar包

    RUN bash -c 'touch /zzyy_docker.jar'

    ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]

    #暴露6001端口作为微服务

    EXPOSE 6001

    2、构建镜像（注意后面有个点）

    docker build -t zzyy_docker:1.6 .

    编写docker-compose.yml文件

    包括微服务、mysql、redis镜像文件。

    1. version: "3"
    2.  
    3. services:
    4.   microService:
    5.     image: zzyy_docker:1.6
    6.     container_name: ms01
    7.     ports:
    8.       - "6001:6001"
    9.     volumes:
    10.       - /app/microService:/data
    11.     networks: 
    12.       - atguigu_net 
    13.     depends_on: 
    14.       - redis
    15.       - mysql
    16.  
    17.   redis:
    18.     image: redis:6.0.8
    19.     ports:
    20.       - "6379:6379"
    21.     volumes:
    22.       - /app/redis/redis.conf:/etc/redis/redis.conf
    23.       - /app/redis/data:/data
    24.     networks: 
    25.       - atguigu_net
    26.     command: redis-server /etc/redis/redis.conf
    27.  
    28.   mysql:
    29.     image: mysql:5.7
    30.     environment:
    31.       MYSQL_ROOT_PASSWORD: '123456'
    32.       MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
    33.       MYSQL_DATABASE: 'db2021'
    34.       MYSQL_USER: 'zzyy'
    35.       MYSQL_PASSWORD: 'zzyy123'
    36.     ports:
    37.        - "3306:3306"
    38.     volumes:
    39.        - /app/mysql/db:/var/lib/mysql
    40.        - /app/mysql/conf/my.cnf:/etc/my.cnf
    41.        - /app/mysql/init:/docker-entrypoint-initdb.d
    42.     networks:
    43.       - atguigu_net
    44.     command: --default-authentication-plugin=mysql_native_password #解决外部无法访问
    45.  
    46. # 自定义网络
    47. networks: 
    48.    atguigu_net:

    编译启动docker-compose

    执行docker-compose up
    或者
    执行docker-compose up -d

    创建数据库

    进入mysql容器实例并新建库db2021+新建表t_user

    docker exec -it 容器实例id /bin/bash

    mysql -uroot -p

    create database db2021;

    use db2021;

    CREATE TABLE `t_user` (
      `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
      `username` VARCHAR(50) NOT NULL DEFAULT '' COMMENT '用户名',
      `password` VARCHAR(50) NOT NULL DEFAULT '' COMMENT '密码',
      `sex` TINYINT(4) NOT NULL DEFAULT '0' COMMENT '性别 0=女 1=男 ',
      `deleted` TINYINT(4) UNSIGNED NOT NULL DEFAULT '0' COMMENT '删除标志，默认0不删除，1删除',
      `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
      `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
      PRIMARY KEY (`id`)
    ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

    停止服务

  • 相关阅读:
    cnn感受野计算方法
    【高等数学基础进阶】函数、极限、连续-补充+练习 & 导数与微分-练习
    人工智能、机器学习、深度学习的区别
    JsJavascriptEcma的eval性能测试2208011912
    1474_AURIX TC275 WDT的运行模式
    学会这些，QtIFW制作安装包不再是难题
    julia系列1：介绍与安装
    什么是 JVM ？
    性能测试的时间间隔获取方法
    防关联浏览器推荐：MuLogin指纹浏览器安全登录多平台账号
  • 原文地址：https://blog.csdn.net/qq_36942720/article/details/133279482