介绍

“phoenix” 是一个灵活可配置的开源监控平台，主要用于监控应用程序、服务器、数据库、网络、tcp端口和http接口，通过实时收集、汇聚和分析监控信息，实现在发现异常时立刻推送告警信息，并且提供了可视化系统进行配置、管理、查看。

• 应用程序
• 默认支持Java应用程序，监控内容包括：在线状态、JVM、业务埋点。其它应用程序需要自己开发客户端，来调用接口与服务端或者代理端通信（心跳接口、服务器信息接口、告警接口）；
• JVM
• 监控内容包括：内存、线程、类、GC等；
• 服务器
• 支持主流服务器，如Linux、Windows、macOS、Unix等；
  监控内容包括：在线状态、操作系统、CPU、平均负载、进程、磁盘、内存、网卡、电池、传感器；
• 数据库
• 支持MySQL、Oracle、Redis、Mongo；
  监控内容：
  ??MySQL：会话；
  ??Oracle：会话、表空间；
  ??Redis：Redis信息全集；
  ??Mongo：Mongo信息全集；
• 网络：支持监控网络状态；
• TCP：支持监控TCP服务状态；
• HTTP：支持监控HTTP服务状态；
• 告警：默认支持电子邮件。

源码和项目地址已经帮大家整理好了，需要的同学转发本文+关注+私信【0628】即可无偿获取

特点

1. 分布式；
2. 跨平台；
3. 支持docker部署；
4. 实时监测告警；
5. 数据加密传输；
6. 灵活可配置；
7. 用户界面支持PC端、移动端。

设计

• 功能架构
• 
  
• 逻辑架构
• 
  
• 运行环境
• Maven3+
  Jdk >=1.8，若使用Sigar监控服务器，则Jdk版本要用1.8(1.8.0_131到1.8.0_241)
  Lombok
  Mysql5.7+
• 技术选型
• 核心框架：SpringBoot
  安全框架：SpringSecurity、SpringSession
  任务调度：JUC、SpringTask、Quartz
  持久层框架：MyBatis、 MyBatis-Plus
  数据库连接池：Alibaba Druid
  日志管理：SLF4J、Logback
  前端框架：Layui、ECharts
  监控框架：Sigar、oshi
• 模块结构
• 平台使用Java + Layui + ECharts开发，数据库采用MySQL。
• phoenix（监控平台父工程）
  ├── phoenix-common（监控公共模块父工程）
  │ ├── phoenix-common-core（监控核心公共模块）
  │ └── phoenix-common-web（监控WEB公共模块）
  ├── phoenix-client（监控客户端父工程）
  │ ├── phoenix-client-core（监控客户端）
  │ ├── phoenix-client-spring-boot-starter（监控客户端与springboot集成的starter）
  │ └── phoenix-client-spring-mvc-integrator（监控客户端与springmvc集成的integrator）
  ├── phoenix-agent（监控代理端）
  ├── phoenix-server（监控服务端）
  ├── phoenix-ui（监控UI端）
  └── doc（文档）
• phoenix：监控平台父工程，管理平台的依赖、构建、插件等；
  phoenix-common：监控公共模块，提供平台所有的公共代码，包含一个监控核心公共模块（phoenix-common-core）和一个监控WEB公共模块（phoenix-common-web）；
  phoenix-client：监控客户端，用于集成到Java应用程序中实现业务埋点和Java应用程序监控信息收集，包含一个通用模块（phoenix-client-core）和与springboot集成的starter（phoenix-client-spring-boot-starter）、与springmvc集成的integrator（phoenix-client-spring-mvc-integrator）两个拓展模块；
  phoenix-agent：监控代理端，用于收集服务器信息和汇聚、转发来自监控客户端的信息；
  phoenix-server：监控服务端，是监控平台的核心模块，用于汇聚、分析监控信息，在发现异常时实时推送告警信息；
  phoenix-ui：监控可视化系统，用于平台配置、用户管理、监控信息查看、图表展示等；
  doc：包含平台的设计文档、服务启停脚本、数据库脚本等。

1. 客户端为普通Java程序

<!-- https://mvnrepository.com/artifact/com.gitee.pifeng/phoenix-client-core -->
<dependency>
  <groupId>com.gitee.pifeng</groupId>
  <artifactId>phoenix-client-core</artifactId>
  <version>${最新稳定版本}</version>
</dependency>

2. 客户端为springboot程序

<!-- https://mvnrepository.com/artifact/com.gitee.pifeng/phoenix-client-spring-boot-starter -->
<dependency>
  <groupId>com.gitee.pifeng</groupId>
  <artifactId>phoenix-client-spring-boot-starter</artifactId>
  <version>${最新稳定版本}</version>
</dependency>

3. 客户端为springmvc程序

<!-- https://mvnrepository.com/artifact/com.gitee.pifeng/phoenix-client-spring-mvc-integrator -->
<dependency>
  <groupId>com.gitee.pifeng</groupId>
  <artifactId>phoenix-client-spring-mvc-integrator</artifactId>
  <version>${最新稳定版本}</version>
</dependency>

• 最新稳定版本
• 1.2.2.RELEASE

使用

初始化“监控数据库”

下载项目源码并解压，进入目录：/phoenix/doc/数据库设计/sql/mysql ，找到SQL脚本并执行即可。

phoenix.sql

编译源码

解压源码,按照maven格式将源码导入IDE, 使用maven进行编译即可。

配置

监控配置

监控配置文件为： monitoring.properties ，放在 classpath:/ 下会自动加载，UI端、服务端、代理端、客户端都需要有这个配置文件。如果是springboot项目也可以分环境配置，示例配置代码如下：

/**
* 开发环境监控配置
*/
@Configuration
@Profile("dev")
@EnableMonitoring(configFileName = "monitoring-dev.properties")
public class MonitoringUiDevConfig {
}

/**
* 生产环境监控配置
*/
@Configuration
@Profile("prod")
@EnableMonitoring(configFileName = "monitoring-prod.properties")
public class MonitoringUiProdConfig {
}

监控配置项说明：

1. 监控UI端
2. 除了在 monitoring-{profile}.properties 文件修改监控配置外，还需要在 application-{profile}.yml 文件修改数据库配置。
3. 监控服务端
4. 需要在 application-{profile}.yml 文件修改数据库配置和邮箱配置。
5. 监控代理端
6. 只需在 monitoring-{profile}.properties 文件修改监控配置。
7. 监控客户端
8. 只需添加监控配置。

加解密配置

除了监控配置文件外，还可以在 classpath:/ 下加入 monitoring-secure.properties 加解密配置文件，用来修改监控平台的加解密方式。但是注意各监控端加解密配置参数必须相同。这个配置不是必须的，没有此配置文件将使用默认加解密配置，加入此配置文件则必须正确配置配置项。

加解密配置项说明：

秘钥可通过 com.gitee.pifeng.monitoring.common.util.secure.SecureUtilsTest#testGenerateKey 方法生成，然后填入配置文件。

第三方登录认证配置

监控UI端除了支持直接登录认证外，还支持第三方登录认证，只需在application.yml（或者application-{profile}.yml）配置文件中增加对应配置项即可使用。

第三方登录认证配置说明：

apereo cas登录认证配置说明：

如果 third-auth.enable=true && third-auth.type=cas ，则需要进行cas配置。

客户端开启监控

• 普通Java程序
• 在 main 方法中，调用方法 Monitor.start() 来开启监控功能，或者调用重载的方法 Monitor.start(configPath, configName) 指定监控配置文件的路径和名字来开启监控功能，如果未指定配置文件路径和名字，则配置文件需要放在 classpath:/ 下，名字必须为 monitoring.properties 。
• springboot程序
• 在启动类上加上注解 @EnableMonitoring 来开启监控功能，或者通过注解的两个参数来指定配置文件的路径和名字，如果未指定配置文件路径和名字，则配置文件需要放在 classpath:/ 下，名字必须为 monitoring.properties 。
• springmvc程序
• 在 web.xml 文件中配置一个监听器，来开启监控功能：

<!-- 开启监控功能 -->
<web-app>
<context-param>
    <param-name>configLocation</param-name>
    <param-value>classpath:monitoring.properties</param-value>
</context-param>
<listener>
  <listener-class>
    com.gitee.pifeng.monitoring.integrator.listener.MonitoringPlugInitializeListener
  </listener-class>
</listener>
</web-app>

业务埋点

Java应用程序只要集成了监控客户端，就具有业务埋点监控的能力，通过 Monitor.buryingPoint() 方法定时监控业务运行情况，通过 Monitor.sendAlarm() 发送告警。具体使用示例如下：

// 业务埋点监控
ScheduledExecutorService service = Monitor.buryingPoint(() -> {
  // 假如发现了业务异常，用下面的代码发送告警
  Alarm alarm = new Alarm();
  alarm.setAlarmLevel(AlarmLevelEnums.ERROR);
  alarm.setTitle("业务埋点监控");
  alarm.setTest(false);
  alarm.setCharset(Charsets.UTF_8);
  alarm.setMsg("测试普通maven程序业务埋点监控！");
  // alarm.setCode("001");
  alarm.setMonitorType(MonitorTypeEnums.CUSTOM);
  Result result = Monitor.sendAlarm(alarm);
  System.out.println("发送业务告警结果：" + result.toJsonString());
}, 0, 1, TimeUnit.HOURS, ThreadTypeEnums.IO_INTENSIVE_THREAD);

时钟同步

部署监控程序（监控UI端、监控服务端、监控代理端、监控客户端）的服务器集群需要进行时钟同步（NTP），保证时间的一致性！。

打包部署运行

Jar包部署

1. 打包
   监控UI端、监控服务端、监控代理端 直接打成可执行jar。

mvn -Dmaven.test.skip=true clean package

2. 上传jar、脚本
3. a.jar路径：phoenix/target
4. b.脚本路径：phoenix/doc/脚本/
5. 运行，脚本说明如下表：
6. 程序脚本命令含义监控UI端phoenix_ui.sh./phoenix_ui.sh start启动./phoenix_ui.sh stop停止./phoenix_ui.sh restart重启./phoenix_ui.sh status检查状态监控服务端phoenix_server.sh./phoenix_ui.sh start启动./phoenix_server.sh stop停止./phoenix_server.sh restart重启./phoenix_server.sh status检查状态监控代理端phoenix_agent.sh./phoenix_agent.sh start启动./phoenix_agent.sh stop停止./phoenix_agent.sh restart重启./phoenix_agent.sh status检查状态

Docker部署

• 方式一：Maven打包远程部署

1. 有一台已经安装好docker环境的服务器，并且允许远程连接（以centos7下的yum方式安装的docker且使用service方式运行为例开启远程连接）：

vi /usr/lib/systemd/system/docker.service  
#确保：ExecStart 的后面有： -H tcp://0.0.0.0:2375  
#修改完成后保存退出，刷新并重启docker服务   
systemctl daemon-reload  
systemctl restart docker  

2. 在系统环境变量中添DOCKER_HOST，如下图所示：

3. 编译项目打包项目并构建镜像

 mvn -Dmaven.test.skip=true clean package docker:build  

4. 运行

监控UI端：

docker run -itd -v /tmp:/tmp -v /liblog4phoenix:/liblog4phoenix -v /etc/localtime:/etc/localtime:ro -p 443:443 --pid host --net host --name phoenix-ui phoenix/phoenix-ui /bin/bash

监控服务端：

docker run -itd -v /tmp:/tmp -v /liblog4phoenix:/liblog4phoenix -v /etc/localtime:/etc/localtime:ro -p 16000:16000 --pid host --net host --name phoenix-server phoenix/phoenix-server /bin/bash

监控代理端：

docker run -itd -v /tmp:/tmp -v /liblog4phoenix:/liblog4phoenix -v /etc/localtime:/etc/localtime:ro -p 12000:12000 --pid host --net host --name phoenix-agent phoenix/phoenix-agent /bin/bash

• 方式二：服务器本地构建docker镜像

1. 打包
   监控UI端、监控服务端、监控代理端 直接打成可执行jar。

mvn -Dmaven.test.skip=true clean package

2. 上传jar、Dockerfile
3. a.jar路径：phoenix/target
4. b.Dockerfile路径：phoenix/phoenix-ui/src/main/docker/Dockerfile、
   phoenix/phoenix-agent/src/main/docker/Dockerfile、
   phoenix/phoenix-server/src/main/docker/Dockerfile，
   Dockerfile 要与对应的jar包放在同一目录下；
5. 构建docker镜像

监控UI端：

docker build -t phoenix/phoenix-ui .

监控服务端：

docker build -t phoenix/phoenix-server .

监控代理端：

docker build -t phoenix/phoenix-agent .

4. 运行

监控UI端：

docker run -itd -v /tmp:/tmp -v /liblog4phoenix:/liblog4phoenix -v /etc/localtime:/etc/localtime:ro -p 443:443 --pid host --net host --name phoenix-ui phoenix/phoenix-ui /bin/bash

监控服务端：

docker run -itd -v /tmp:/tmp -v /liblog4phoenix:/liblog4phoenix -v /etc/localtime:/etc/localtime:ro -p 16000:16000 --pid host --net host --name phoenix-server phoenix/phoenix-server /bin/bash

监控代理端：

docker run -itd -v /tmp:/tmp -v /liblog4phoenix:/liblog4phoenix -v /etc/localtime:/etc/localtime:ro -p 12000:12000 --pid host --net host --name phoenix-agent phoenix/phoenix-agent /bin/bash

集群部署

监控服务端、监控UI端支持集群部署，提升系统的容灾和可用性。

集群部署时的几点要求和建议：

1. DB配置保持一致；
2. 集群机器时钟保持一致（单机集群忽视）；
3. 建议：推荐通过nginx为集群做负载均衡。监控服务端、监控UI端均通过nginx进行访问。

访问

监控UI端 访问URL：http(s)://localhost/phoenix-ui/index ，开发环境(dev)使用http，生产环境(prod)使用https，初始账号/密码：admin/admin123，guest/guest123。

功能截图

源码和项目地址已经帮大家整理好了，需要的同学转发本文+关注+私信【0628】即可无偿获取

SpringBoot入门最详细教程

网上有很多springboot的入门教程，自己也因为项目要使用springboot，所以利用业余时间自学了下springboot和springcloud，使用下来发现springboot还是挺简单的，体现了极简的编程风格，大部分通用都是通过注解就可以完成，下面就来详细讲解下如何使用springboot来开发一个简单的restful api网关功能，可以提供给H5或者android、ios进行接口开发，还是很方便的。

1. 使用spring initialization创建SpringBoot项目

有很多方法可以快速创建Springboot项目，可以通过idea的springboot initialization来创建，也可以通过手工新建一个maven工程，然后引入springboot的dependency来完成sprignboot的工程导入，还可以通过spring官网的来创建springboot项目，因为有些同学可能没装idea，这里就通过官网的工程初始化指引来创建一个springboot空工程。

在serch for dependency输入web，即可完成基本的restful接口网关的功能，如果要JPA或者oauth安全相关的组件，可以增加rest repository、spring security等相关组件依赖库，spring提供的配套组件还是很多的，基本涵盖了所有应用场合。
加入web组件后，点击下方的绿色按钮Generate Project即可创建一个springboot工程，并且自动下载到本地，接下来直接在idea或者eclipse打开该工程就可以了，在创建的时候可以选择Maven工程或者Gradle工程，这里我们使用了大家比较熟悉的Maven工程。

2. 工程结构

下面我们在ide中打开工程，这里使用的ide是idea，工程的目录结构为：

image

可以看到工程中有maven的pom文件，也自动创建了SpringbootStartApplication.java该类为springboot的启动类，待会儿我们一起看下这个类，先看下maven的pom文件有哪些。这里主要是依赖了springboot的1.4.7版本，目前最新已经更新到1.5.6了，这里没有用最新版本，还是不当小白鼠了，在dependency中依赖了spring-boot-starter-web还有个test测试的组件，如果不写测试代码，可以不使用该test组件，最后还加入了支持springboot的maven plugin组件。

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <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>

刚看完了pom文件，在导入工程的时候，ide一般会自动导入依赖库，在国内访问maven的依赖库速度感人，建议使用阿里云的maven镜像服务器，或者使用公司的maven私服，如果公司没有私服或者自己学习可以直接使用阿里云的镜像速度还是不错的，maven setting.xml中需要添加mirror地址，具体如何配置这里就不详细描述了，可以自行百度，这里也顺便附上阿里云maven地址：

<mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>*</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

配置好了pom后，我们一起看下自动生成的Application.java这个类相当于我们程序的main函数入口，这里再顺便介绍下因为springboot集成了Tomcat和Jetty，默认使用Tomcat作为应用容器，开发者只需要将工程打成jar包直接丢到服务器上就可以执行了，不需要再单独部署到was、jboss、tomcat这些应用服务器上。
SpringBootStartApplication.java

@SpringBootApplication
public class SpringbootStartApplication {

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

所有的springboot application启动类都需要在类级别上加上@SpringBootApplication注解，其他参数不用任何调整，后续可以把一些初始化的动作放到该类中进行，目前本例中就不加其他的启动加载项了。
这样一个api网关的架子就搭好了，是不是很简单！下面我们就可以将主要精力聚焦在业务逻辑代码上了，这里为了简化程序，不会将项目进行深入的分层设计，在实际项目中，一般都会对项目进行分层设计，如果是api网关，没有view层但是起码也会有对外接入decontroller层、处理业务逻辑的service层、处理数据持久化的dao层，同时也会有一些POJO业务实体类，这里就不详细展开了，后续也会对互联网架构设计进行详细讲述，这里我们只创建了一个UserController类，里面只有获取用户信息的方法，分别根据参数和请求方式的不同用三种方法进行了重写，下面就来一一道来。

先来讲述下最简单的使用get请求用户信息的实现方式，代码如下,写好后直接在Application类点击右键有个RunAs，点击后会自动运行，运行成功后可以使用http发包工具进行测试，这里推荐使用chrome的postman或者使用firefox的httprequester插件，都是比较简单的发包工具，get请求的上送为http://localhost:8081/springboot/getUserByGet?userName=feiweiwei

//@RestController注解能够使项目支持Rest
@RestController
@SpringBootApplication
//表示该controller类下所有的方法都公用的一级上下文根
@RequestMapping(value = "/springboot")
public class UserController {
    //这里使用@RequestMapping注解表示该方法对应的二级上下文路径
    @RequestMapping(value = "/getUserByGet", method = RequestMethod.GET)
    String getUserByGet(@RequestParam(value = "userName") String userName){
        return "Hello " + userName;
    }
}

这里用到的注解主要有@RequestMapping表示请求的URL上下文路径，该路径不能重复，为了保证与团队其他同事写的不重复，一般会在每个controller前面加一个一级上下文目录，具体路径参数放在value后面，在每个方法前加一个二级目录，这样可以有效的避免路径冲突。还有注解是@RequestParam，该注解可以通过value指定入参，这里return的返回值就是实际的接口返回。

下面介绍下POST的请求方式，可以通过在@RequestMapping注解中设置method为POST来表示该请求为POST请求，除了get、post还有put、delete等请求方式，都可以通过该参数设置。

    //通过RequestMethod.POST表示请求需要时POST方式
    @RequestMapping(value = "/getUserByPost", method = RequestMethod.POST)
    String getUserByPost(@RequestParam(value = "userName") String userName){
        return "Hello " + userName;
    }

下面介绍下请求参数为JSON格式的请求方法的写法，这里需要注意下如果请求参数是像上面那样通过url form形式提交的请求参数，那么必须使用@RequestParam注解来标示参数，如果使用的请求报文是POST形势的JSON串，那么这里在入参的注解一定要使用@RequestBody，否则会报json解析错误。

//在入参设置@RequestBody注解表示接收整个报文体，这里主要用在接收整个POST请求中的json报文体，
//目前主流的请求报文也都是JSON格式了，使用该注解就能够获取整个JSON报文体作为入参，使用JSON解析工具解析后获取具体参数

    //在入参设置@RequestBody注解表示接收整个报文体，这里主要用在接收整个POST请求中的json报文体，
    //目前主流的请求报文也都是JSON格式了，使用该注解就能够获取整个JSON报文体作为入参，使用JSON解析工具解析后获取具体参数
    @RequestMapping(value = "/getUserByJson",method = RequestMethod.POST)
    String getUserByJson(@RequestBody String data){
        return "Json is " + data;
    }

小结
到此一个简单的restful风格的api网关就完成了，对于移动开发人员可以自己写简单的服务端进行全栈开发了，原来做spring的同学也可以很快上手springboot，springboot总体上来说还是简化了原先复杂的配置，让大家更容易快速上手和搭建服务端