Java微服务架构1
目录
linux篇（Ubuntu）
1.Linux目录结构说明
2.Linux操作文件目录说明
4.Linux重启和压缩命令
5.Linux编辑器的使用
6.Linux软件的安装和卸载
7.Linux用户和组的管理
8.Linux文件权限的管理
9.配置环境变量
10.安装mysql
Docker篇
1.docker安装
2.docker加速器
3.docker的虚悬镜像的查看和删除
4.dockerfile定制镜像
Docker Compose篇
GitLab篇
Nexus篇
springboot篇
创建通用的父级接口
src/main/java下创建tk.mybattis
/src/main/resources/generator/generatorConfig.xml
/src/main/resources/ /jdbc.properties
创建入口类
创建测试类
SpringCloud篇
linux篇（Ubuntu）
1.Linux目录结构说明
Linux安装软件文件是分散到以下这些目录中的，和Windows安装软件有所区别，所以我们要了解这些目录结构
bin目录：存放二进制可执行文件（比如：ls,cat,mkdir等等）
boot目录：存放用于系统引导时使用的各种文件
dev目录：用于存放设备文件
etc目录：用于存放系统配置文件（比如说hosts修改ip等等）
home目录：存放所有用户文件的根目录
lib目录:存放跟文件系统中的程序运行所需要的共享库及内核模块 （相当于存放第三方依赖的，这里存放的是Linux的依赖）
mnt目录；系统管理员安装临时文件系统的安装点
opt目录：额外安装可选应用程序包所放置的位置
proc目录：虚拟文件系统，存放当前内存的映射
root目录：超级用户目录
sbin：存放二进制文件，只有root才能访问（专门存放root权限的可执行文件）
usr:用于存放系统应用程序比较重要的目录是/usr/local本地管理员安装目录
var目录：用于存放运行时需要改变数据的文件
注意：不要在根目录下创建任何文件或者文件夹，我们只需要操作的一般只有home目录和/usr/local目录
2.Linux操作文件目录说明
ll:列出当前目录结构（需要管理员权限）
ls:列出当前目录结构(ls -al 类似于ll命令) ls -rlt -r：反向排序-t：列出文件按照最后修改时间（最新的在上面）-l：长格式显示
mkdir -p 目录名称 (穿件目录)
touch 文件名称 （创建空文件）
echo 内容 > 文件名称（创建一个带内容的文件，两个尖括号表示追加）
cat 文件名称 （显示文件内容）
cp dir/文件 todir/文件名称（拷贝改名）
rm (-f强制删除 -r同事删除目录下的文件)
mv dir/文件 todir/(移动剪切)
find -name '关键字'（查找）
ln 需要创建软连接的位置以及文件 目标 (建立软连接，相当于快捷方式，挂载)
more 文件 （分页显示） more **.log more **.log.2021-01-21 |grep '关键字'
view **.log（查看文件内容）
head (显示文件开头内容)
tail (显示文件结尾内容，常用的是 tail -f 日志文件)
grep(检索文件) grep -C 10 '该账户登录出错已达上限' **.log（查出关键字部分上下10行）
ps -ef|grep tomcat（查看进程）
kill -9 350098（杀进程）
3.Linux系统管理命令
stat 文件名称（显示指定文件相关信息，比ls命令信息显示更详细）
who (显示在线登录用户)
hostname(显示系统名称)
uname(显示系统信息)
top(相当于Windows下的任务管理器中的进程)
du -h 文件（显示当前文件（目录）已使用磁盘空间的总量）
df -h (显示文件系统磁盘空间的使用情况)
free -h(显示当前内存和交换空间的使用情况)
clear(清屏)
kill (杀死进程)
natstat -al(显示网络状态信息 )
ping (测试网络的连通性)
4.Linux重启和压缩命令
reboot(重启，需要超级管理员权限 临时获取超级管理员权限 sudo reboot)
shutdown -r now(重启)
shutdown -h now(关机)
--------------------------------------------------------------------------------------------------
tar -czvf my.tar.gz 打包的文件或目录（压缩）
tar -xzvf my.tar.gz 解压到的目录(解压)
tar -cjvf my.tar.bz2 打包的文件或目录(压缩)
tar -xjvf my.tar.gz 解压到的目录 (解压)
unzip test.zip ->将test.zip解压到当前文件下
unzip -n test.zip -d /tmp ->将test.zip解压到/tmp目录下，并且不要覆盖已有文件
unzip -v test.zip ->查看test.zip内容，但不解压
unzip -o test.zip -d tmp/ ->将test.zip解压到/tmp目录下，并且覆盖已有文件
5.Linux编辑器的使用
vim 文件（编辑文件内容）
输入 i 进入插入模式；
输入 ： 进入命令模式；
：q 退去
：wq 保存退出
：q! 强退
：w file 将当前内容保存成某个文件
：set number 显示行数
6.Linux软件的安装和卸载
ubuntu 下软件包管理是通过apt这个程序管理的，centos下软件包管理是通过yum这个程序管理的
sudo apt-get install nano(安装nano应用程序)
sudo apt-get remove nano(删除nano应用程序)
下载软件地址，这里的地址默认是Ubuntu官网的地址
可以配置镜像加速器
lsb_release -a(查看系统版本,修改数据源需要用到该名称)
cd /etc/apt
cp sources.list sources.list.old(备份)
vi /etc/apt/sources.list
删除所有内容插入
|
|
sudo apt-get update(更新数据源)
再次下载应用程序会很快
其他命令：
| apt-get upgrade(升级有可用更新的系统（最好不用）) apt-cache search 名称（搜索） apt-cache show名称（获取包信息） apt-get install 名称（再安装一次及更新） apt-get check(检查是否有损坏的依赖) apt-get clean && apt-get sutoclean(清理无用的包) apt-get source 名称（下载源码） apt-get build-dep 名称（安装相关的编译环境） sudo apt-get autoremove 名称(删除应用程序以及依赖） |
----------------------------------------------------------------------------------------------------------------
扩展：
Yum(全称为 Yellow dogUpdater, Modified)是一个在Fedora和RedHat以及CentOS中的Shell前端软件包管理器。基于RPM包管理，能够从指定的服务器自动下载RPM包并且安装，可以自动处理依赖性关系，并且一次安装所有依赖的软件包，无须繁琐地一次次下载、安装。yum提供了查找、安装、删除某一个、一组甚至全部软件包的命令，而且命令简洁而又好记。
安装
yum install 全部安装
yum install package1 安装指定的安装包package1
yum groupinsall group1 安装程序组group1
更新和升级
yum update 全部更新
yum update package1 更新指定程序包package1
yum check-update 检查可更新的程序
yum upgrade package1 升级指定程序包package1
yum groupupdate group1 升级程序组group1
查找和显示
yum info package1 显示安装包信息package1
yum list 显示所有已经安装和可以安装的程序包
yum list package1 显示指定程序包安装情况package1
yum groupinfo group1 显示程序组group1信息yum search string 根据关键字string查找安装包
删除程序
yum remove | erase package1 删除程序包package1
yum groupremove group1 删除程序组group1
yum deplist package1 查看程序package1依赖情况
清除缓存
yum clean packages 清除缓存目录下的软件包
yum clean headers 清除缓存目录下的 headers
yum clean oldheaders 清除缓存目录下旧的 headers
yum clean, yum clean all (= yum clean packages; yum clean oldheaders) 清除缓存目录下的软件包及旧的headers
1,备份一下原本的yum源：
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
2.进入yum源所在文件夹
cd /etc/yum.repos.d/3,下载阿里云的yum源【我下的是CentOS7的，如果需要其他版本，那么只需要将下面的7改成5或6即可】【这一步需要能联网】：
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
或者
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo4,之后运行给install生成缓存
yum makecache5.更新yum
yum -y update7.Linux用户和组的管理
让Linux系统允许使用root账号远程登录:
sudo passwd root(设置root用户的密码)
vi /etc/ssh/sshd_config(配置项将原先的without-password修改为 yes)
service ssh restart(重启 ssh服务)
groupadd -g 666 zookeeper (创建组并且制定id)
useradd -g zookeeper -d /home/zookeeper -s /bin/bash -u 666 zookeeper(添加用户并且指定组，起始目录，脚本和id)
root 用户所在的群组叫 wheel
usermod -g wheel zookeeper （修改用户所属的群组）
passwd zookeeper（设置密码）
使用zookeeper用户登录，在/home/zookeeper/.bash_profile中添加如下内容：
|
配置环境变量： JAVA_HOME=/usr/java/jdk1.6.0_45 export JAVA_HOME PATH=$JAVA_HOME/bin:$PATH export PATH set -o vi alias l='ls -ltr' alias la='ls -ltrA' |
修改完成后，执行以下命令，使用环境变量生效：
. ~/.bash_profile
8.Linux文件权限的管理
chmod（修改权限）
语法：chmod [who] [+ | - | =] [mode] 文件名
方法1：使用数字改变文件或路径的权限
权限分数如下：
r：4
w：2
x：1
身份包括：
user：u、group：g、other：o
例如：-rwxrwx--- 代表文件的的权限分别为：
user：4+2+1=7
group：4+2+1=7
other：0+0+0=0
注：若是这样drwxrwx---，第一个字母为d，表示是路径，权限与上面一样
把文件权限改为-rwxr-xr-x
chmod 755 file
注：若是目录的话，代码为：chmod 755 dir；目录里面的全部为755，则：chmod 755 -R dir
方法2：使用符号类型改变文件权限
user：u + (加入) r
group：g - (除去) w 文件或目录
other：o = (设置) x
all：a
chmod a+x file 给u、g和o添加执行权限
chmod u-w file 给u除去可写权限
也可以这样用法：chmod u=rwx,go=rx file 等价于 chmod 755 file
----------------------------------------------------------------------------------------------
chown（修改所属用户和组）
语法：chown [选项]... [所有者][:[组]] 文件...
-c 显示更改的部分的信息
-f 忽略错误信息
-h 修复符号链接
-R 处理指定目录以及其子目录下的所有文件
-v 显示详细的处理信息
-deference 作用于符号链接的指向，而不是链接文件本身
--reference=<目录或文件> 把指定的目录/文件作为参考，把操作的文件/目录设置成参考文件/目录相同拥有者和群组
--from=<当前用户：当前群组> 只有当前用户和群组跟指定的用户和群组相同时才进行改变
--help 显示帮助信息
--version 显示版本信息
chown 组名1:组名2 文件名
把 /var/run/httpd.pid 的所有者设置 root：
chown root /var/run/httpd.pid将文件 file1.txt 的拥有者设为 runoob，群体的使用者 runoobgroup :
chown runoob:runoobgroup file1.txt将当前前目录下的所有文件与子目录的拥有者皆设为 runoob，群体的使用者 runoobgroup:
chown -R runoob:runoobgroup *把 /home/runoob 的关联组设置为 512 （关联组ID），不改变所有者：
chown :512 /home/runoob9.配置环境变量
Ubuntu
environment （系统环境变量）
profile（用户环境变量）
-----------------------------------------------------------------------------------
redhat中设置环境变量PATH的方法：
（1）如果只是想在本次开机临时性的添加修改，下次开机就无效的话，可以：
输入export PATH=$PATH:/sbin
（2）如果只给当前用户永久添加，则：
在~/.bash_profile中，类似这样的一行PATH=$PATH:$HOME/bin后添加:/sbin，就变成PATH=$PATH:$HOME/bin:/sbin
文件修改并保存后，运行source ~/.bash_profile命令即可使修改操作立即生效。
（3）如果给系统中所有的用户都永久添加，则：
在/etc/profile文件中添加pathmunge :/sbin
如：/etc/profile文件打开后有如下代码
# Path manipulation
if [ "$EUID" = "0" ];then
pathmunge/sbin
pathmunge/usr/sbin
pathmunge /usr/local/sbin
fi
........................
将之改成：
# Path manipulation
if [ "$EUID" = "0" ];then
pathmunge/sbin
pathmunge/usr/sbin
pathmunge /usr/local/sbin
pathmunge/usr/local/arm/bin
fi
........................
表示将/usr/local/arm/bin添加进环境变量。
文件修改并保存后，运行source etc/profile命令即可使修改操作立即生效。
1）etc/profile
此文件为系统的每个用户设置环境信息，当用户第一次登录时，该文件被执行。并从/etc/profile.d目录的配置文件中搜集shell的设置。
注：在这里我们设定是为所有用户可使用的全局变量。
2）/etc/bashrc
为每一个运行bash shell的用户执行此文件。当bash shell被打开时，该文件被读取。
3）~/.bash_profile
每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时，该文件仅仅执行一次!默认情况下，他设置一些环境变量，执行用户的.bashrc文件。
4）~/.bashrc
该文件包含专用于你的bash shell的bash信息，当登录时以及每次打开新的shell时，该文件被读取。
3和4都是在用户目录下的，他们唯一的不同是: .bash_profile只能在登录的时候启动一次。在Ubuntu里面似乎没有3这个文件。
~/.bash_profile 是交互式、login方式进入 bash 运行的
~/.bashrc 是交互式 non-login 方式进入 bash 运行的
通常二者设置大致相同，所以通常前者会调用后者。
10.安装mysql
apt-get install mysql-server
y
安装完成
status mysql.service(检查其状态)
mysqladmin -p -u version(查看版本)
whereis mysql
cd /etc/mysql
（原因：没有开通远程连接）
cd /etc/mysql/mysql.conf.d
修改以下文件（开通远程连接）
service mysql restart(重启)
（原因;需要赋权）
mysql -u root -p(登录mysql)
授权root用户允许所有人登录
grant all privileges on *.* to 'root'@'%' identified by '密码'；
| 因弱口令无法成功授权解决：
validate_password插件是mysql5.6以后可以引入的一个新密码校验插件,在mysql5.7之后会自动安装的 查看和设置密码级别 select @@validate_password_policy; set global validate_password_policy=0; 查看和设置密码长度 select @@validate_password_length; set global validate_password_length=6； |
0 or LOW
校验级别最低，只校验密码长度，只要长度跟validate_password_length一样即可，默认长度是8位。
1 or MEDIUM
这个时候首先要满足的是validate_password_policy=0时的验证要求。然后现去验证密码中的数字个数，大小写个数，特殊字符个数。这些又分别由validate_password_number_count，validate_password_mixed_case_count，validate_password_special_char_count 这几个参数来控制。
2 or STRONG
这个时候必须先满足0，1的要求，然后它还追加了一个，对于密码中任意连续4个(或4个让上)字符不得是字典中的单词（validate_password_dictionary_file）
Docker篇
docker官方镜像仓库（DockerHub）：Docker Hub
1.docker安装
使用脚本自动安装：
curl -fsSL get.docker.com -o get-docker.sh
sh get-docker.sh --mirror Aliyun
删除docker
2.docker加速器
3.docker的虚悬镜像的查看和删除
我们平时可能会看到这样一个镜像，这个镜像既没有仓库名，也没有 标签，均为
可 以用下面的命令专门显示这类镜像：
docker images -f dangling=true
一般来说，虚悬镜像已经失去了存在的价值，是可以随意删除的，可以用下面的命 令删除。
docker rmi $(docker images -q -f dangling=true)
4.dockerfile定制镜像
构建镜像到私服
Docker Compose篇
1.什么是Compose
服务架构的应用系统一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停，那么效率之低，维护量之大可想而知。
使用 Docker Compose 可以轻松、高效的管理容器，它是一个用于定义和运行多容器 Docker 的应用程序工具。
提示：可以是用 .yml 或 .yaml 作为文件扩展名
2.安装 Docker Compose
sudo curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-'uname -s'-'uname -m' > /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
3.Docker Compose基本使用
cd /usr/local
mkdir -p docker/tomcat
vi docker-compose.yml
| version: '3' services: tomcat: restart:always image:tomcat container_name:tomcat poots: - 8080:8080 |
version：docker compose版本
version 定义了版本信息
这个定义关乎与docker的兼容性
具体为
Compose 文件格式有3个版本,分别为1, 2.x 和 3.x
目前主流的为 3.x 其支持 docker 1.13.0 及其以上的版本
images用来指定服务的镜像名称或镜像ID，如果镜像在本地不存在，compose将会尝试去拉取这个镜像。
web，这个名字是用户自己自定义，它就是服务名称。
volumes指令用于设置数据卷挂载路径，数据卷挂载路径可以是一个目录或一个已经存在的数据卷容器，可以设置宿主机路径HOST:CONTAINER或加上访问模式HOST:CONTAINER:ro。使用ro表示对于容器来说数据卷是只读的，这样可以有效地保护宿主机的文件系统。
networks指令用于设置指定网络。
#版本号
version: "2.1"
# 指定创建的虚拟网络数量
# 作用：通过不同的虚拟网络实现了容器网络之间的隔离，从而在最大程度上去保护后端网络的安全。
#networks:
# mynet:
# driver: bridge
# mynet1:
# 重用的代码模板
# 模板的定义必须以 x- 开头
x-logging:
# 以 & 开头的字符串为模板命名
# 以 * 加上模板的名称引用模板
&default-logging
driver: json-file
options:
max-size: "200k"
max-file: "10"
# 定义全局挂载卷
volumes:
test_1.thinking.com:
test_2.thinking.com:
# 服务
services:
#服务名称
todo:
# 构建镜像
build:
# 指定dockerfile的上下文路径（相对当前docker-compose.yml的位置）
# 包含Dockerfile文件的目录路径，或者是git仓库的URL。
# 当提供的值是相对路径时，它被解释为相对于当前compose文件的位置。
# 该目录也是发送到Docker守护程序构建镜像的上下文。
context: .
# Dockerfile的文件名称
dockerfile: Dockerfile-todo
args:
# 变量
buildno: 1
password: secret
# Dockerfile里面可使用的参数变量
# Dockerfile：
# ARG buildno
# ARG password
# RUN echo "Build number: $buildno"
# RUN script-requiring-password.sh "$password"
# 镜像名 ： 仓库/标签:版本
image: zhanyang/todo-demo:1.0.0
# 依赖(以指定顺序启动)
depends_on:
mysql:
condition: service_healthy
# 指定一个自定义容器名称，而不是生成的默认名称。
# 由于Docker容器名称必须是唯一的，因此如果指定了自定义名称，则无法将服务扩展到多个容器。
container_name: todo
# 卷挂载路径设置。
# 可以设置宿主机路径 （HOST:CONTAINER） 或加上访问模式 （HOST:CONTAINER:ro）
# 挂载数据卷的默认权限是读写（rw），可以通过ro指定为只读。
volumes:
# 只需指定一个路径，让引擎创建一个卷
- /var/lib/mysql
# 指定绝对路径映射
- /opt/data:/var/lib/mysql
# 相对于当前compose文件的相对路径
- ./cache:/tmp/cache
# 用户家目录相对路径
- ~/configs:/etc/configs/:ro
# 命名卷
- datavolume:/var/lib/mysql
# 使用全局挂载卷
- test_1.thinking.com:/test:rw
# 指定日志驱动为 json-file，存储日志的最大文件 size 为 200k，最多存储 10 这样大的文件。
# logging支持很多driver，而每一个driver对应的options都不一样
# docker inspect -f {
{.HostConfig.LogConfig}} lnmp-nginx
# result：{json-file map[max-file:10 max-size:2000k]}
# docker info |grep 'Logging Driver'
# result：Logging Driver: json-file
# 其他：https://docs.docker.com/engine/admin/logging/overview/
logging:
driver: "json-file"
options:
max-size: "200k"
max-file: "10"
# 指定使用的虚拟网络
networks:
# - mynet
# 覆盖容器启动后默认执行的命令。
# 该命令也可以是一个类似于dockerfile的列表：command: ["bundle", "exec", "thin", "-p", "3000"]
command: bundle exec thin -p 3000
# may
command: ["/usr/local/nginx/sbin/nginx"]
# 链接到另一个服务中的容器。 请指定服务名称和链接别名（SERVICE：ALIAS），或者仅指定服务名称。
# 实际是通过设置/etc/hosts的域名解析，从而实现容器间的通信。
# 故可以像在应用中使用localhost一样使用服务的别名链接其他容器的服务，前提是多个服务容器在一个网络中可路由联通
# links也可以起到和depends_on相似的功能，即定义服务之间的依赖关系，从而确定服务启动的顺序
links:
- db
- db:database
- redis
# 链接到docker-compose.yml 外部的容器，甚至并非 Compose 管理的容器。参数格式跟 links 类似。
external
- redis_1
- project_db_1:mysql
- project_db_1:postgresql
# 暴露端口，但不映射到宿主机，只被连接的服务访问。 仅可以指定内部端口为参数
expose:
- "3000"
- "8000"
# 暴露端口信息。使用宿主：容器 （HOST:CONTAINER）格式或者仅仅指定容器的端口（宿主将会随机选择端口）都可以。
ports:
- "3000"
- "3000-3005"
- "8000:8000"
- "9090-9091:8080-8081"
- "49100:22"
- "127.0.0.1:8001:8001"
- "127.0.0.1:5000-5010:5000-5010"
- "6060:6060/udp"
# v3.2中ports的长格式的语法允许配置不能用短格式表示的附加字段。
ports:
- target: 80 #容器内的端口
published: 8080 #物理主机的端口
protocol: tcp #端口协议（tcp或udp）
mode: host #host 和ingress 两总模式，host用于在每个节点上发布主机端口，ingress 用于被负载平衡的swarm模式端口。
# no是默认的重启策略，在任何情况下都不会重启容器。
restart: "no"
# 指定为always时，容器总是重新启动。
restart: always
# 如果退出代码指示出现故障错误，则on-failure将重新启动容器。
restart: on-failure
restart: unless-stopped
# pid 将PID模式设置为主机PID模式。
# 这就打开了容器与主机操作系统之间的共享PID地址空间。
# 使用此标志启动的容器将能够访问和操作裸机的命名空间中的其他容器，反之亦然。
# 即打开该选项的容器可以相互通过进程 ID 来访问和操作。
pid: "host"
# 配置 DNS 服务器。可以是一个值，也可以是一个列表。
dns: 8.8.8.8
dns:
- 8.8.8.8
- 9.9.9.9
# 自定义搜索域
dns_search: example.com
dns_search:
- dc1.example.com
- dc2.example.com
# 覆盖Dockerfile中的entrypoint，用法同Dockerfile中的用法
entrypoint: ["/usr/local/nginx/sbin/nginx","-g","daemon off;"]
# 添加环境变量。 你可以使用数组或字典两种形式。
# 任何布尔值; true，false，yes，no需要用引号括起来，以确保它们不被YML解析器转换为True或False。
environment:
RACK_ENV: development
SHOW: 'true'
SESSION_SECRET:
# 【注意】：如果你的服务指定了build选项，那么在构建过程中通过environment定义的环境变量将不会起作用。
# 将使用build的args子选项来定义构建时的环境变量。
environment:
- RACK_ENV=development
- SHOW=true
- SESSION_SECRE
# 1>将定义的变量编写在文件中，然后在yml文件中进行添加
env_file: .env
env_file:
- ./common.env
- ./apps/web.env
- /opt/secrets.env
# 2>例如：
# old：
db:
image: mysql
ports:
- "3306:3306"
environment:
MYSQL_ROOT_PASSWORD: redhat
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress
# new：
db:
image: mysql
ports:
- "3306:3306"
env_file: ./mysql_env
# 创建env_file文件在当前目录mysql_env
MYSQL_ROOT_PASSWORD=redhat
MYSQL_DATABASE=wordpress
MYSQL_USER=wordpress
MYSQL_PASSWORD=wordpress3
# 添加hostname映射，类似于docker cli下面的--add-host
extra_hosts:
- "www.hcstart.com:192.168.101.14"
# 配置一个检查去测试服务中的容器是否运行正常
# 具体： https://docs.docker.com/engine/reference/builder/#healthcheck
# 查看healthcheck的状态输出 ： docker inspect lnmp-nginx
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 1m30s
timeout: 10s
retries: 3
# labels:添加元数据到container中，查看现有容器的labels：
# docker inspect -f {
{.Config.Labels}} lnmp-nginx # lnmp-nginx ：容器名
labels:
com.example.description: "Accounting webapp"
com.example.department: "Finance"
com.example.label-with-empty-value: ""
labels:
- "com.example.description=Accounting webapp"
- "com.example.department=Finance"
- "com.example.label-with-empty-value"
# 在容器中设置内核参数
sysctls:
net.core.somaxconn: 1024
net.ipv4.tcp_syncookies: 0
sysctls:
- net.core.somaxconn=1024
- net.ipv4.tcp_syncookies=0
mysql:
environment:
MYSQL_ROOT_PASSWORD: password
MYSQL_DATABASE: tododb
MYSQL_USER: user
MYSQL_PASSWORD: pass
build:
context: .
dockerfile: Dockerfile-mysql
image: zhanyang/mysql:5.6
container_name: mysql
# 以 * 加上模板的名称引用模板 使用全局自定义模板
logging: *default-logging
# 指定使用的虚拟网络
networks:
# - mynet1
4.常用命令
docker-compose ps(查看容器列表)
docker-compose up(启动，一般需要上下文，在docker-compose.yml中执行）
docker-compose down(删除，一般需要上下文，在docker-compose.yml中执行)
GitLab篇
1.基于Docker安装GitLab
Docker Hub
(这个是gitLab中文版)
修改内存为2048MB,最好放在主分区C盘中
docker pull twang2218/gitlab-ce-zh
cd /usr/local
mkdir -p docker/gitlab
cd docker/gitlab
vi docker-compose.yml
| version: '3' services: web: image: 'twang2218/gitlab-ce-zh' restart: always hostname: 192.168.75.145 environment: TZ: 'Asia/Shanghai' GITLAB_OMNIBUS_CONFIG: external_url: 'http://192.168.75.145:8080' gitlab_rails['gitlab_shell_ssh_port'] = 2222 unicorn['port'] = 8888 nginx['listen_port'] = 8080 ports: - '8080:8080' - '8443:443' - '2222:22' volumes: - /usr/local/docker/gitlab/config:/etc/gitlab - /usr/local/docker/gitlab/data:/var/opt/gitlab - /usr/local/docker/gitlab/logs:/var/log/gitlab |
docker-compose up
本地访问：192.168.75.145：8080
设置管理员密码,管理员账号是root
2.ssh免密登录
本地打开git安装目录到/usr/bin下
cmd命令行
ssh-keygen -t rsa -C "注册邮箱地址"
Nexus篇
1.安装
(内存至少分配2GB)
docker pull sonatype/nexus3
cd /usr/local/
mkdir -p docker/nexus
cd docker/nexus
vi docker-compose.yml
| version: '3.1' services: nexus: restart: always image: sonatype/nexus3 container_name: nexus ports: - 8081:8081 volumes: - /usr/local/docker/nexus/data:/nexus-data |
chmod 777 data
docker-compose up -d
2.nexus的使用
setting.xml中配置
pom.xml中配置
代理
上传测试: 命令（mvn deploy -Dmaven.test.skip=true）
如果是快照版本，那么在mvn deploy时会自动发布到快照版本库中，会覆盖老的快照版本，而在使用快照版本的模块，在不更改版本号的情况下，直接编译打包时，maven会自动从镜像服务器上下载最新的快照版本。如果是正式发布版本，那么在mvn deploy时会自动发布到正式版本库中，而使用正式版本的模块，在不更改版本号的情况下，编译打包时如果本地已经存在该版本的模块则不会主动去镜像服务器上下载。
mvn clean package依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)等７个阶段。
mvn clean install依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)、install等8个阶段。
mvn clean deploy依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)、install、deploy等９个阶段。
由上面的分析可知主要区别如下，
package命令完成了项目编译、单元测试、打包功能，但没有把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库
install命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库，但没有布署到远程maven私服仓库
deploy命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库
docker私服registry搭建
可以指定版本号，默认为latest
安装管理端
下面管理端是和registry一起装的
生成秘钥，gitlab新增，部署项目，一次构建，到处运行（Ubuntu）
安装maven环境变量
vi /etc/profile
souce /etc/profile
mvn -v
过滤git项目文件
springboot篇
1.优缺点
优点：
- 快读构建项目
- 对主流开发框架的无配置集成
- 项目可独立运行，无需外部依赖servlet容器
- 提供运行时的应用监控
- 极大的提高开发和部署效率
缺点：
- 版本迭代速度快
- 由于不用自己做配置，报错是很难定位
2.springboot第一个程序
|
|
| @RestController @SpringBootApplication public class HelloSpringBootApplication{ psvm{ SpringApplication.run(HelloSpringBootApplication.class,args); } @RequestMapping(value=””,method=”RequestMethod.GET”) public String sayHi(){ return(“hello spring boot”); } } |
|
|
测试类
|
@RunWith(SpringRunner.class) @SpringBootTest(classes = “HelloSpringBootApplication.class”,webEnvironment = “SpringBootTest.WebEnvironment.RANDOM_PORT”) public class HelloSpringBootApplicationTests{ @LocalServerPort private int port; private URL base;
@Autowired private TestRestTemplate template; @Before public void setup() throws Exception{ this.base = new URL(http://localhost:+port+”/”); } @Test public void contextLoads(){ ResponseEntity // 匹配符 anyOf 表示任何一个条件满足则成立，类似于逻辑或 "||"， 匹配符 containsString 表示是否含有参数子 assertThat(response.getBody(),equalTo(“Hello Spring Boot”)); } } |
| 扩展：断言 字符相关匹配符 /**equalTo匹配符断言被测的testedValue等于expectedValue， * equalTo可以断言数值之间，字符串之间和对象之间是否相等，相当于Object的equals方法 */ assertThat(testedValue, equalTo(expectedValue)); /**equalToIgnoringCase匹配符断言被测的字符串testedString *在忽略大小写的情况下等于expectedString */ assertThat(testedString, equalToIgnoringCase(expectedString)); /**equalToIgnoringWhiteSpace匹配符断言被测的字符串testedString *在忽略头尾的任意个空格的情况下等于expectedString， *注意：字符串中的空格不能被忽略 */ assertThat(testedString, equalToIgnoringWhiteSpace(expectedString); /**containsString匹配符断言被测的字符串testedString包含子字符串subString**/ assertThat(testedString, containsString(subString) ); /**endsWith匹配符断言被测的字符串testedString以子字符串suffix结尾*/ assertThat(testedString, endsWith(suffix)); /**startsWith匹配符断言被测的字符串testedString以子字符串prefix开始*/ assertThat(testedString, startsWith(prefix)); 一般匹配符 /**nullValue()匹配符断言被测object的值为null*/ assertThat(object,nullValue()); /**notNullValue()匹配符断言被测object的值不为null*/ assertThat(object,notNullValue()); /**is匹配符断言被测的object等于后面给出匹配表达式*/ assertThat(testedString, is(equalTo(expectedValue))); /**is匹配符简写应用之一，is(equalTo(x))的简写，断言testedValue等于expectedValue*/ assertThat(testedValue, is(expectedValue)); /**is匹配符简写应用之二，is(instanceOf(SomeClass.class))的简写， *断言testedObject为Cheddar的实例 */ assertThat(testedObject, is(Cheddar.class)); /**not匹配符和is匹配符正好相反，断言被测的object不等于后面给出的object*/ assertThat(testedString, not(expectedString)); /**allOf匹配符断言符合所有条件，相当于“与”（&&）*/ assertThat(testedNumber, allOf( greaterThan(8), lessThan(16) ) ); /**anyOf匹配符断言符合条件之一，相当于“或”（||）*/ assertThat(testedNumber, anyOf( greaterThan(16), lessThan(8) ) ); 数值相关匹配符 /**closeTo匹配符断言被测的浮点型数testedDouble在20.0¡À0.5范围之内*/ assertThat(testedDouble, closeTo( 20.0, 0.5 )); /**greaterThan匹配符断言被测的数值testedNumber大于16.0*/ assertThat(testedNumber, greaterThan(16.0)); /** lessThan匹配符断言被测的数值testedNumber小于16.0*/ assertThat(testedNumber, lessThan (16.0)); /** greaterThanOrEqualTo匹配符断言被测的数值testedNumber大于等于16.0*/ assertThat(testedNumber, greaterThanOrEqualTo (16.0)); /** lessThanOrEqualTo匹配符断言被测的testedNumber小于等于16.0*/ assertThat(testedNumber, lessThanOrEqualTo (16.0)); 集合相关匹配符 /**hasEntry匹配符断言被测的Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项*/ assertThat(mapObject, hasEntry("key", "value" ) ); /**hasItem匹配符表明被测的迭代对象iterableObject含有元素element项则测试通过*/ assertThat(iterableObject, hasItem (element)); /** hasKey匹配符断言被测的Map对象mapObject含有键值“key”*/ assertThat(mapObject, hasKey ("key")); /** hasValue匹配符断言被测的Map对象mapObject含有元素值value*/ assertThat(mapObject, hasValue(value)); |
3.Thymeleaf
-
动静结合：Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。
-
开箱即用：它提供标准和spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果，避免每天套模板、该jstl、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。
-
多方言支持：Thymeleaf 提供spring标准方言和一个与 SpringMVC 完美集成的可选模块，可以快速的实现表单绑定、属性编辑器、国际化等功能。
-
与SpringBoot完美整合，SpringBoot提供了Thymeleaf的默认配置，并且为Thymeleaf设置了视图解析器，我们可以像以前操作jsp一样来操作Thymeleaf。代码几乎没有任何区别，就是在模板语法上有区别。
| <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-thymeleafartifactId> dependency>
<dependency> <groupId>net.sourceforge.nekohtmlgroupId> <artifactId>nekohtmlartifactId> dependency> |
| spring: thymeleaf: cache:false mode:LEGACYHTML5 encoding:UTF-8 servlet: content-type:text/html |
src/main/resources/templats下创建index.html
| 创建测试页面
xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
charset="UTF-8"> name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> http-equiv="X-UA-Compatible" content="ie=edge">
th:text="${name}">李四
创建控制类 @Controller public class thymeleafController { @RequestMapping(value={“”,”index”},method=”RequestMethod.GET”) public String index(Model model){ model.addAttribute("name", "Lusifer"); return "index"; } } |
|
|
4.springboot整合mybatis
|
|
| server: port: 8080 spring: datasource: druid: url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=false username: root password: 123456 initial-size: 1 min-idle: 1 max-active: 20 test-on-borrow: true driver-class-name: com.mysql.jdbc.Driver mybatis: mapper-locations: classpath:mapper/*Mapper.xml(resources目录下) type-aliases-package: com.example.entity(实体类存放路径) |
创建通用的父级接口src/main/java下创建tk.mybattis/** * 特别注意，该接口不能被springboot扫描到，否则会报错 **/ public interface MyMapper } /src/main/resources/generator/generatorConfig.xml
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
driverClass="${jdbc.driveClass}" connectionURL="${jdbc.connectionURL} " userId="${jdbc.username}" password="${jdbc.password}">
< /table > #jdbc.driver = com.mysql.jdbc.Driver @SpringBootApplication @MapperScan(basePackage = “com.funtl.hello.spring.mybatis.dao”) public class HelloSpringBootMybatisApplication{ psvm(){ SpringApplication.run(HelloSpringBootMybatisApplication.class,args); } } @RunWith(SpringRunner.class) @SpringBootTest(classes = HelloSpringBootMybatisApplication.class) @Transactional @Rollback Public class HelloSpringBootMybatisApplicationTest{ //自动生成的mapper @AutoWired Private TbUserMapper mapper; @Test Public void testSelect(){ List //循环输出 } @Test Public void testPage(){ PageHelper.startPage(1,10); Example example = new Example(TbUser.class); PageInfo< TbUser > pageinfo =new PageInfo(mapper.selectByExample(example)); List< TbUser > list = Pageinfo.getList(); //循环输出 } } 1.搭建项目(每个目录代表一个工程) 本地创建hello-spring-cloud目录--->IDEA打开刚刚所创建的目录 创建统一依赖管理hello-spring-cloud-dependencies 创建pom.xml xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 2.服务的注册于发现（eureka） 创建统一依赖管理hello-spring-cloud-eureka-->创建pom.xml 添加依赖，找到本地对应的pom文件，点击ok 创建maven目录 src/main/java和 src/main/resources 创建配置文件 以上步骤在每个项目中都适用 创建工程：hello-spring-cloud-eureka xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 创建package在java目录下 com.funtl.hello/spring.cloud/eureka //入口 @SpringBootApplication @EnableEurekaServer public class EurekaApplication{ psvm(){SpringApplication.run(EurekaApplication.class,args)} } spring: spplication: name: hello-spring-cloud-eureka server: port: 8761 eureka: instance: hostname: localhost client: registerWithEureka: false fetchRegistry: false serviceUrl: defaultZone: http://${ eureka.instance.hostname }:${server.port}/eureka/ 3.springcloud创建服务提供者 创建项目hello-spring-cloud-servcie-admin xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> spring: spplication: name: hello-spring-cloud-service-admin server: port: 8762 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ 创建package在java目录下 com.funtl.hello/spring.cloud/eureka //入口 @SpringBootApplication @EnableEurekaClient public class ServiceAdminApplication{ psvm(){SpringApplication.run(ServiceAdminApplication.class,args)} } //提供服务 @RestController public class AdminController{ @Value("${server.port}") public String port; @RequestMapping(value = "hi",method = RequestMethod.GET) public String sayHi(String message){ return String.format("Hi your message is : %s port :%s",message,port); } } 4.SpringCloud创建服务消费者 Resttemplate+Ribbon 创建工程：hello-spring-cloud-web-admin-ribbon spring: spplication: name: hello-spring-cloud-web-admin-ribbon thymeleaf: cache:false mode:LEGACYHTML5 encoding:UTF-8 servlet: content-type:text/html server: port: 8764 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ //入口 @SpringBootApplication @EnableDisccoveryClient public class WebAdminRibbonApplication{ psvm(){SpringApplication.run(WebAdminRibbonApplication.class,args)} } //创建配置类在src/main/java/***/config包下 @Configuration public class RestTemplateConfiguration{ @Bean @LoadBalanced//负载均衡配置 Public RestTemplate restTemplate(){ return new RestTemplate(); } } //创建service在src/main/java/***/service包下 @Service public class AdminService{ @AutoWired private RestTemplate restTemplate; public String sayHi(String message){ return restTemplate.getForObject(http://hello-spring-cloud-service-admin/hi?message= + message,String.class); } } //创建controller在src/main/java/***/controller包下 @RestController public class AdminConller{ @AutoWired private AdminService adminService; @RequestMapping(value = “hi”,method = RequestMethod.GET) public String sayHi(Stirng message){ return adminService. SayHi(message); } } Feign 创建工程：hello-spring-cloud-web-admin-feign spring: spplication: name: hello-spring-cloud-web-admin-feign thymeleaf: cache:false mode:LEGACYHTML5 encoding:UTF-8 servlet: content-type:text/html server: port: 8765 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/cc //入口 @SpringBootApplication @EnableDisccoveryClient @EnableFeignClients public class WebAdminFeignApplication{ psvm(){SpringApplication.run(WebAdminFeignApplication.class,args)} } //创建service接口在src/main/java/***/service包下 @FeignClient(value = “hello-spring-cloud-service-admin”) public interface AdminService{ @RequestMapping(value = “hi”,method = RequestMethod.GET) public String sayHi(@ReuqestParm(value = “message”)String message); } //创建controller在src/main/java/***/controller包下 @RestController public class AdminConller{ @AutoWired private AdminService adminService; @RequestMapping(value = “hi”,method = RequestMethod.GET) public String sayHi(Stirng message){ return adminService. sayHi(message); } } 5.熔断器 基于ribbon改造 //入口 @EnableHystrix//开启熔断器 @SpringBootApplication @EnableDisccoveryClient public class WebAdminRibbonApplication{ psvm(){SpringApplication.run(WebAdminRibbonApplication.class,args)} } //创建配置类在src/main/java/***/config包下 @Configuration public class RestTemplateConfiguration{ @Bean @LoadBalanced//负载均衡配置 Public RestTemplate restTemplate(){ return new RestTemplate(); } } //创建service在src/main/java/***/service包下 @Service public class AdminService{ @AutoWired private RestTemplate restTemplate; @HystrixCommand(fallbackMethod="hiError") public String sayHi(String message){ return restTemplate.getForObject(http://hello-spring-cloud-service-admin/hi?message= + message,String.class); } public String hiError(String message){ return String.format("hi your message is : %s but request bad",message); } } //创建controller在src/main/java/***/controller包下 @RestController public class AdminConller{ @AutoWired private AdminService adminService; @RequestMapping(value = “hi”,method = RequestMethod.GET) public String sayHi(Stirng message){ return adminService. SayHi(message); } } Feign自带熔断器(基于Feign改造) spring: spplication: name: hello-spring-cloud-web-admin-feign thymeleaf: cache:false mode:LEGACYHTML5 encoding:UTF-8 servlet: content-type:text/html server: port: 8765 feign: hystrix: enabled: true eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ //入口 @SpringBootApplication @EnableDisccoveryClient @EnableFeignClients public class WebAdminFeignApplication{ psvm(){SpringApplication.run(WebAdminFeignApplication.class,args)} } //创建service接口在src/main/java/***/service包下 @FeignClient(value = “hello-spring-cloud-service-admin”,fallback = "AdminServiceHystrix .class") public interface AdminService{ @RequestMapping(value = “hi”,method = RequestMethod.GET) public String sayHi(@ReuqestParm(value = “message”)String message); } //创建service实现接口在src/main/java/***/service/hystrix包下 @Component public class AdminServiceHystrix implements AdminService{ @Override public String sayHi(String message){ return String.format("hi your message is : %s but request bad",message); } } //创建controller在src/main/java/***/controller包下 @RestController public class AdminConller{ @AutoWired private AdminService adminService; @RequestMapping(value = “hi”,method = RequestMethod.GET) public String sayHi(Stirng message){ return adminService. sayHi(message); } } 5.Hystrix熔断器仪表盘监控 基于feign改造 //入口 @SpringBootApplication @EnableDisccoveryClient @EnableFeignClients @EnableHystrixDashboard public class WebAdminFeignApplication{ psvm(){SpringApplication.run(WebAdminFeignApplication.class,args)} } //Spring中没有web.xml，所有需要手动配置 //创建service接口在src/main/java/***/config包下 @Configuration public classHystrixDashboardConfiguration{ @Bean public ServletRegistrationBean getServlet(){ HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet (); ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet ); registrationBean.setLoadOnStartup(1);//启动顺序 registrationBean.addUrlMappings(“/hystrix.stream”);//访问路径 registrationBean.setName("HystrixMetricsStreamServlet"); return registrationBean; } } 访问hystrix 触发熔断器进行监控 6.使用路由网关统一访问接口 创建工程：hello-spring-cloud-zuul spring: spplication: name: hello-spring-cloud-zuul server: port: 8769 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ zuul: routes: api-a: path: /api/a/** serviceId: hello-spring-cloud-web-admin-ribbon api-b: path: /api/b/** serviceId: hello-spring-cloud-web-admin-feign //入口 @SpringBootApplication @EnableEurekaClient @EnableZuulProxy public class ZuulApplication{ psvm(){SpringApplication.run(ZuulApplication.class,args)} } //创建失败回调类 在src/main/java/***/provider包下 @Component public class WebAdminFeignFallbackProvider implements FallbackProvider{ @Override public String getRoute() { // ServiceId，如果需要所有调用都支持回退，则 return "*" 或 return null return "hello-spring-cloud-web-admin-feign"; } /** * 如果请求服务失败，则返回指定的信息给调用者 * @param route * @param cause * @return */ @Override public ClientHttpResponse fallbackResponse(String route, Throwable cause) { return new ClientHttpResponse() { /** * 网关向 api 服务请求失败了，但是消费者客户端向网关发起的请求是成功的， * 不应该把 api 的 404,500 等问题抛给客户端 * 网关和 api 服务集群对于客户端来说是黑盒 * @return * @throws IOException */ @Override public HttpStatus getStatusCode() throws IOException { return HttpStatus.OK; } @Override public int getRawStatusCode() throws IOException { return HttpStatus.OK.value(); } @Override public String getStatusText() throws IOException { return HttpStatus.OK.getReasonPhrase(); } @Override public void close() { } @Override public InputStream getBody() throws IOException { ObjectMapper objectMapper = new ObjectMapper(); Map map.put("status", 200); map.put("message", "无法连接，请检查您的网络"); return new ByteArrayInputStream(objectMapper.writeValueAsString(map).getBytes("UTF-8")); } @Override public HttpHeaders getHeaders() { HttpHeaders headers = new HttpHeaders(); // 和 getBody 中的内容编码一致 headers.setContentType(MediaType.APPLICATION_JSON_UTF8); return headers; } }; } } 7.路由网关的服务过滤功能 基于hello-spring-cloud-zuul实现 //创建失过滤器 在src/main/java/***/filter包下 /** * Zuul 的服务过滤演示 * Title: LoginFilter * Description: * * @author snake * @version 1.0.0 * @date 2018/5/29 22:02 */ @Component public class LoginFilter extends ZuulFilter { private static final Logger logger = LoggerFactory.getLogger(LoginFilter.class); /** * 配置过滤类型，有四种不同生命周期的过滤器类型 * 1. pre：路由之前 * 2. routing：路由之时 * 3. post：路由之后 * 4. error：发送错误调用 * @return */ @Override public String filterType() { return "pre"; } /** * 配置过滤的顺序，数字越小越靠前 * @return */ @Override public int filterOrder() { return 0; } /** * 配置是否需要过滤：true/需要，false/不需要 * @return */ @Override public boolean shouldFilter() { return true; } /** * 过滤器的具体业务代码 * @return * @throws ZuulException */ @Override public Object run() throws ZuulException { RequestContext context = RequestContext.getCurrentContext(); HttpServletRequest request = context.getRequest(); logger.info("{} >>> {}", request.getMethod(), ); String token = request.getParameter("token"); if (token == null) { logger.warn("Token is empty"); context.setSendZuulResponse(false); context.setResponseStatusCode(401); try { HttpServletResponse response = context.getResponse(); response.setContentType("text/html;charset=utf-8"); context.getResponse().getWriter().write("非法请求"); } catch (IOException e) { } } else { logger.info("OK"); } return null; } } 8.分布式配置中心——服务端 创建项目hello-spring-cloud-config xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> spring: spplication: name: hello-spring-cloud-config cloud: config: label: master //分支 server: git: http://192.168.75.128/Lusifer/Spring-cloud-config search-paths: respo //目录地址 username:账号 password:密码 //springcloudconfig默认端口为8888，如果要改，需要新增bootstrap.properties，添加server.port=端口号 server: port: 8888 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ //创建入口类 @SpringBootApplication @EnableConfigServer @EnableEurekaClient//服务提供者 public class ConfigApplication{ psvm(){ SpringApplicatiob.run(ConfigApplication.class,args); } } 9.分布式配置中心——客户端 <dependency> //添加全局依赖 //在需要被管理的服务上都只配置以下内容 spring: cloud: config: uri: http://localhost:8888 //配置中心服务端地址 name: web-admin-feign //application名称 label: master //分支 profile: dev //profile名称 上测试用test,上生产用prod 实际开发中我们有三套环境 1.开发环境 application-dev.yml 2.测试环境 application-test.yml或者application-testing.yml 3.生产环境 application-prod.yml 注意application可以自由命名 在实际应用中，我们可以根据启动参数来配置服务要用的配置文件： mvn clean package 打包jar文件 ------------------------------------------------------------------- 可配置三个，三个配置中只要更改profile: 参数即可，默认启动不带参数用application.yml 启动默认配置 java -jar XXXXX.jar 启动生产配置 java -jar XXXX.jar --spring.profiles.active=prod 10.zipkin服务链路追踪 创建工程hello-spring-cloud-zipkin <dependency> <dependency> <dependency> //添加全局依赖 解决依赖冲突 //创建入口类 @SpringBootApplication @EnableCZipkinServer @EnableEurekaClient//服务提供者 public class ZipkinApplication{ psvm(){ SpringApplicatiob.run(ZipkinApplication.class,args); } } spring: application: name:hello-spring-cloud-zipkin server: port: 9411 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ management: metrics: web: server: auto-time-requests: true 在所有需要被追踪的项目中（除了dependencies）中增加speing-cloud-starter-zipkin依赖 <dependency> 在yml配置中添加 spring: zipkin: base-url:http://localhost:9411 11.服务监控——服务端 创建工程hello-spring-cloud-admin <dependency> <dependency> spring: application: name:hello-spring-cloud-admin server: port: 8084 managemen: endpoint: health: show-details: always endpoint: web: exposure: include: health,info //*表示全开 eureka: client: serviceUrl: defaultZone: http://localhost:8761 /eureka/ //创建入口类 @SpringBootApplication @EnableAdminServer @EnableEurekaClient//服务提供者 public class AdminApplication{ psvm(){ SpringApplicatiob.run(AdminApplication.class,args); } } 12.服务监控——客户端 //全局依赖 //每个需要被监控的项目都需要拷贝 spring: boot: admin: client: url:http://localhost:8084 managemen: endpoint: health: show-details: always endpoint: web: exposure: include: health,info //*表示全开 //所有的项目都要添加 //创建入口类 所有的项目都要被监控，所以入口类没有需要被修改的地方 微服务启动顺序： 1：注册于发现 2.分布式配置中心 3.服务提供者 4.服务消费者 5.API网关 |
