docker+jib整合springboot+mysql專案

阿新 • • 發佈：2020-08-28

第一步：在 IDE 上快速建立一個 springboot 專案(博主用的是 IDEA)

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

        <!-- 資料庫 ORM 框架 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        
        <!-- setter/getter 註解 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true 
</optional>
        </dependency>

專案依賴

專案結構：

第二步：快速建立一個 UserMsg 的實體類

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.io.Serializable;

/**
 * @author chaoyou
 * @email 
 * @date 2020-8-27 18:51
 * @Description
 * @Reference
  
*/

@Entity
@Table(name = "user_msg")
@Setter
@Getter
@JsonIgnoreProperties({"handler", "hibernateLazyInitializer"})
public class UserMsg implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @Column
    private String username;
    @Column
     
private String password;

    public UserMsg() {
    }

    public UserMsg(String username, String password) {
        this.username = username;
        this.password = password;
    }
}

UserMsg實體類

import lombok.Getter;
import lombok.Setter;

/**
 * @author chaoyou
 * @email 
 * @date 2020-8-27 19:11
 * @Description
 * @Reference
 */
@Setter
@Getter
public class UserMsgForm {
    private String username;
    private String password;
}

UserMsg表單類

第三步：UserMsg 實體類的 dao 層

import com.example.demo.model.UserMsg;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;

import java.io.Serializable;

/**
 * @author chaoyou
 * @email 
 * @date 2020-8-27 18:55
 * @Description
 * @Reference
 */
public interface UserMsgDao extends CrudRepository<UserMsg, Serializable> {
    @Query(value = "select * from user_msg where username = ?1", nativeQuery = true)
    UserMsg getByUsername(String username);

    UserMsg getByUsernameAndPassword(String username, String password);
}

Dao 層

第四步：UserMsg 實體類的 service 層

import com.example.demo.model.UserMsg;

/**
 * @author chaoyou
 * @email 
 * @date 2020-8-27 18:57
 * @Description
 * @Reference
 */
public interface UserMsgService {
    public String save(UserMsg userMsg);
    public Object get(String username);
}

service

import com.example.demo.dao.UserMsgDao;
import com.example.demo.model.UserMsg;
import com.example.demo.service.UserMsgService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author chaoyou
 * @email 
 * @date 2020-8-27 18:58
 * @Description
 * @Reference
 */
@Service
public class UserMsgServiceImpl implements UserMsgService {

    private UserMsgDao dao;
    @Autowired
    public UserMsgServiceImpl(UserMsgDao dao) {
        this.dao = dao;
    }

    @Override
    public String save(UserMsg userMsg) {
        String reuslt = "";
        try {
            UserMsg userMsg1 = dao.getByUsernameAndPassword(userMsg.getUsername(), userMsg.getPassword());
            if (userMsg1 != null){
                return "【username=" + userMsg.getUsername() + ", password=" + userMsg.getPassword() + "】賬號資訊已經存在！";
            }
            dao.save(new UserMsg(userMsg.getUsername(), userMsg.getPassword()));
            reuslt = "success";
        } catch (Exception e){
            reuslt = "新建賬號失敗！";
        }
        return reuslt;
    }

    @Override
    public Object get(String username) {
        Object reuslt = "";
        try {
            reuslt = dao.getByUsername(username);
        } catch (Exception e){
            reuslt = "查詢賬戶資訊失敗！";
        }
        return reuslt;
    }
}

service 實現類

第五步：UserMsg 實體類的 controller 層

import com.example.demo.model.UserMsg;
import com.example.demo.model.form.UserMsgForm;
import com.example.demo.service.UserMsgService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author chaoyou
 * @email 
 * @date 2020-8-27 19:09
 * @Description
 * @Reference
 */
@RestController
@RequestMapping("/user")
public class UserMsgController {

    @Autowired
    private UserMsgService service;

    @PostMapping(value = "/save", produces = "application/json;charset=utf-8")
    public ResponseEntity save(UserMsgForm userMsgForm){
        String result = "";
        if (ObjectUtils.isEmpty(userMsgForm)){
            result = "賬號資訊不能為空！";
        } else {
            UserMsg userMsg = new UserMsg();
            BeanUtils.copyProperties(userMsgForm, userMsg, "id");
            result = service.save(userMsg);
        }
        return ResponseEntity.ok(result);
    }

    @GetMapping(value = "/get", produces = "application/json;charset=utf-8")
    public ResponseEntity get(String username){
        Object result = "";
        if (ObjectUtils.isEmpty(username)){
            result = "賬號資訊不能為空！";
        } else {
            result = service.get(username);
        }
        return ResponseEntity.ok(result);
    }
}

controller

第六步：設定執行環境配置檔案

server.address=0.0.0.0
server.port=8080
server.tomcat.uri-encoding=UTF-8
server.connection-timeout=1000000
server.error.whitelabel.enabled=false
server.max-http-header-size=102400
spring.datasource.name=mysql
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.filters=stat
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.druid.url=jdbc:mysql://localhost:3306/db?useSSL=false&useUnicode=true&characterEncoding=utf-8&characterSetResults=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&autoReconnect=true&failOverReadOnly=false&createDatabaseIfNotExist=true&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true
spring.datasource.druid.username=root
spring.datasource.druid.password=123456
spring.datasource.druid.initial-size=6
spring.datasource.druid.min-idle=2
spring.datasource.druid.max-active=700
spring.datasource.druid.max-wait=600000
spring.datasource.druid.time-between-eviction-runs-millis=600000
spring.datasource.druid.min-evictable-idle-time-millis=3000000
spring.datasource.druid.validation-query=SELECT 'x'
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.pool-prepared-statements=false
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.devtools.restart.additional-paths=src/main/java
spring.devtools.restart.exclude=static/**,public/**
spring.output.ansi.enabled=always
spring.mvc.throw-exception-if-no-handler-found=true
spring.mvc.static-path-pattern=/**
spring.resources.add-mappings=true
spring.resources.chain.strategy.content.enabled=true
spring.resources.chain.strategy.content.paths=/**
spring.servlet.multipart.max-file-size=128KB
spring.servlet.multipart.max-request-size=128KB
spring.servlet.multipart.enabled=false


## springdata \uFFFD\uFFFD\uFFFD\u00F2\uFFFD\uFFFD\uFFFD
## jpa 開啟駝峰命名規則
spring.jpa.hibernate.naming.implicit-strategy=org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
## hibernate 自動建表
spring.jpa.hibernate.ddl-auto=update
# 控制檯列印 sql 語句
spring.jpa.show-sql=true
# 資料庫方言
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
debug=false
trace=false
spring.jpa.open-in-view=true
# 解決 hibernate 懶載入問題
spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

#spring.jackson.mapper.use-std-bean-naming=true        #// 允許欄位命名不規範 解決首字母大寫的問題(不轉小寫)   猶豫之前對接的都是小寫  所以這個屬性不放開  沿用原來的對接

# json 轉物件 忽略大小寫問題
spring.jackson.mapper.ACCEPT_CASE_INSENSITIVE_PROPERTIES=true        

# 日誌規範
logging.level.org.hibernate.sql=DEBUG
logging.level.org.hibernate.type=ERROR
logging.level.org.springframework.web=ERROR
logging.path=build/log
logging.level.root=warn
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n


logging.level.cc=error

spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true

# 設定多執行緒系統引數
book.core.poolsize=20
book.max.poolsize=30
book.queue.capacity=300
book.keepAlive.seconds=100
book.thread.name.prefix=taskExecutorWbswryxx-

application-dev.properties

# 設定專案的執行環境(dev：開發、prod：生產、test：測試)
spring.profiles.active=dev
#spring.profiles.active=test
#spring.profiles.active=prod

application.properties

第七步：在 pom.xml 中設定 jib-maven-plugin 外掛資訊

<?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 http://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.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <!--Maven 屬性-->
    <properties>
        <!--專案的編碼格式-->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- maven 編譯資源 版本 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <!-- maven 編譯目標版本  -->
        <maven.compiler.target>1.8</maven.compiler.target>
        <!-- maven 編譯外掛版本 -->
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>

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

        <!-- 資料庫 ORM 框架 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!--使用jib外掛-->
            <plugin>
                <groupId>com.google.cloud.tools</groupId>
                <artifactId>jib-maven-plugin</artifactId>
                <version>1.3.0</version>
                <configuration>
                    <!--from節點用來設定映象的基礎映象，相當於Docerkfile中的FROM關鍵字-->
                    <from>
                        <!--使用openjdk官方映象，tag是8-jdk-stretch，表示映象的作業系統是debian9,裝好了jdk8-->
                        <image>openjdk:8-jdk-stretch</image>
<!--                        <image>mysql:8.0</image>-->
                    </from>
                    <to>
                        <!--映象名稱和tag，使用了mvn內建變數${project.version}，表示當前工程的version-->
                        <image>chaoyou/${project.name}:${project.version}</image>
                    </to>
                    <!--容器相關的屬性-->
                    <container>
                        <!--jvm記憶體引數-->
                        <jvmFlags>
                            <jvmFlag>-Xms128m</jvmFlag>
                            <jvmFlag>-Xmx128m</jvmFlag>
                        </jvmFlags>
                        <!--要暴露的埠-->
                        <ports>
                            <port>8080</port>
                        </ports>
                    </container>
                    <!--開啟允許上傳映象到倉庫中-->
                    <allowInsecureRegistries>true</allowInsecureRegistries>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

pom.xml

第八步：把專案推送到 Linux 上

第九步：在 docker 上跑一個 mysql 容器

##搜尋 mysql 映象
——docker search mysql8.0

##拉取 mysql8.0 映象
——docker pull mysql8.0

##跑 mysql 映象
——docker run -d -p 3306:3306 --name mysqltest -e MYSQL_ROOT_PASSWORD=123456 docker.io/mysql:8.0

##進入 mysqltest 容器內部
——docker exec -it mysqltest /bin/bash

##檢視容器內部ip
——cat /etc/hosts

第十步：進入專案的配置檔案中修改資料庫的 ip 地址

#進入application-dev.properties
——cd src/main/resources

#修改 application-dev.properties 資訊(把ip換成mysqltest容器的內部ip)
——vi application.properties

第十一步：進入到該專案的 pom.xml 同級目錄下

接下來利用 jib 外掛對專案進行打包成映象包(jib-image.tar)，有個前提 Linux 環境有安裝 jdk 和 maven(安裝參考：https://www.cnblogs.com/chaoyou/p/13572888.html)

#打包命令

[root@localhost demo]# mvn compile jib:buildTar

打包完成進入 target 目錄下就可以看到映象包( jib-image.tar )

第十二步：把映象包( jib-image.tar )推進 docker 映象庫( docker images )

##把映象包( jib-image.tar )推進 docker 倉庫
[root@localhost target]# docker load < jib-image.tar

##把 docker 映象庫中的映象打包成 tar 映象包
[root@localhost target]# docker save -o /chaoyou/demo.tar chaoyou/demo:0.0.1-SNAPSHOT

第十三步：跑 chaoyuou/demo 映象

#跑映象
——docker run --rm -p 8080:8080 chaoyou/demo:0.0.1-SNAPSHOT

docker+jib整合springboot+mysql專案

第一步：在 IDE 上快速建立一個 springboot 專案(博主用的是 IDEA) <dependency> <groupId>org.springframework.boot</groupId>

使用docker-compose部署springboot專案

1、打包一個jar 2、建立springboot的映象，將jar包和Dockerfile放在一個目錄 Dockerfile

docker部署skywalking,以及.NETCore專案IIS部署整合

之前寫過一篇基於Linux下的Skywalking的部署，關於skywalking的介紹可以看這個https://www.cnblogs.com/shook/p/10852691.html

SpringBoot員工管理系統（整合Mybatis+mysql）

技術標籤：Spring Bootmybatismysql資料庫javaspring SpringBoot員工管理系統（整合Mybatis+mysql）

docker中部署和啟動springboot測試專案

技術標籤：從0開始建站 1，檢視防火牆狀態 firewall-cmd --state 2，遠端傳遞springboot.jar

Springboot/Springcloud專案中整合redis進行使用

前言：Redis支援五種資料型別：string（字串），hash（雜湊），list（列表），set（集合），zset(sorted set：有序集合)。

Docker Devops---Git和MySql構建持續整合的版本控制和資料庫環境

Docker DevOps（一）安裝Git和MySql構建持續整合的版本控制和資料庫環境 1.安裝docker

IDEA通過Docker外掛部署SpringBoot專案

IDEA通過Docker外掛部署SpringBoot專案 IDEA通過Docker外掛部署SpringBoot專案文章目錄 1、配置Docker遠端連線埠

docker持續整合java專案

前言關於Docker的文章鋪天蓋地，但精品文章往往翻譯居多。都說Docker天生適合持續整合/持續部署，但同樣，可落地、實際可操作性的文章也很罕見。

springboot與xxl-job，附上與docker-compose整合

springboot與xxl-job整合，附上與docker-compose啟動前言因為公司內部專案需要經常匯出一些報表發給領導，以及很多時候需要定時傳送訊息，所以需要一個定時任務框架，最好它能夠實時修改生效以及頁面維護，

騰訊雲伺服器Ubuntu在docker部署springboot+mysql

記錄docker部署專案操作 1.docker執行啟動 sudo systemctl start docker 驗證docker正常 sudo docker run hello-world

實踐丨SpringBoot整合Mybatis-Plus專案存在Mapper時報錯

摘要：在SpringBoot執行測試Mybatis-Plus測試的時候報錯的問題分析與修復本文分享自華為雲社群《SpringBoot整合MybatisPlus專案存在Mapper時執行報錯的問題分析與修復》，作者：攻城獅Chova 。

Docker+Jenkins持續整合環境（2）使用docker+jenkins構建nodejs前端專案

前文使用Docker搭建Jenkins+Docker持續整合環境我們已經搭建了基於docker+jenkins的持續整合環境，並構建了基於maven的專案。這一節，我們繼續擴充套件功能，增加對Nodejs的支援,實現nodejs專案構建、並打包成docker

RabbitMQ從概念到使用、從Docker安裝到RabbitMQ整合Springboot【1.5w字保姆級教學】

@ 目錄一、前言二、RabbitMQ作用 1. 非同步處理 2. 應用解耦 3. 流量控制三、RabbitMQ概念

Redis實戰--Redis整合SpringBoot示例

echo編輯整理，歡迎轉載，轉載請宣告文章來源。歡迎新增echo微信(微訊號：t2421499075)交流學習。百戰不敗，依不自稱常勝，百敗不頹，依能奮力前行。——這才是真正的堪稱強大！！！

docker-compose部署全棧專案（vue+node.js+mongodb）

第一次投稿，寫這篇文章主要是記錄自己這周從0開始學習docker到部署專案。 image：應用程式及其依賴，打包在 image 檔案裡面。可以想象成一個類。

使用docker部署django技術棧專案

本文最早釋出DeanWu的技術部落格：pylixm.cc/posts/2019-… 題圖來源網路。隨著Docker的普及成熟，已經逐漸成為部署專案的首選，今天來和大家分享下如何使用docker部署django技術棧專案。

shiro整合springboot前後端分離

本文例項為大家分享了shiro整合springboot前後端分離的具體程式碼，供大家參考，具體內容如下

如何把springboot jar專案改為war專案

這篇文章主要介紹瞭如何把springboot jar專案改為war專案,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

springboot web專案打jar或者war包並執行的實現

（一）springboot web專案打jar包 1、打包兩種打包方式 maven命令打包切換目錄到工程根下，pom.xml所在位置，執行maven的打包命令

docker+jib整合springboot+mysql專案

相關推薦