jenkins使用

说明：jenkins是一个能实现项目自动化部署管理的工具

准备工作

下载软件：/jenkins.io/download/ 下载war包就可以了，在不同的平台上都可以通用

安装git、maven工具

git1.7.1在和Jenkins使用的时候会出现问题，这里建议是用1.7.1以上的 由于centos6自带的git就是1.7.1的，所以我是编译安装的，安装步骤如下：

1）安装依赖工具

<code>yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel</code>

2）下载源代码，我用的是2.7.4 /mirrors.edge.kernel.org/pub/software/scm/git/

<code>cd git-2.7.4
make prefix=/usr/local/git all
make prefix=/usr/local/git install
vim /etc/profile
/ 在末尾新开一行填写下面的代码
export PATH=$PATH:/usr/local/git/bin
/ :wq保存退出，然后执行下面的命令，让其生效
source /etc/profile
/ 查看git版本
git --version</code>

maven安装 /maven.apache.org/download.cgi 我下载最新版3.5.3 将文件放在/usr/local/下 配置环境变量：

<code>MAVEN_HOME=/usr/local/apache-maven-3.5.3
export MAVEN_HOME
export PATH=${MAVEN_HOME}/bin</code>

运行jenkins并创建项目

启动：在服务器上运行: nohup java -jar jenkins.war &
控制台会打印出初始化的用户名和密码 至此就在浏览器打开页面，输入账号就可以登录到管理界面，jenkins会自动扫描服务器上的安装的maven、git服务

新建一个项目：

选择项目源码位置，这里使用gitlab来管理源码，下面是登陆到gitlab的账号
(365) 526-8809

因为我使用的是maven项目，填写maven构建的执行命令，我这里是打包成一个war包

添加构建后的操作，比如上传到war包到服务器，然后备份原来的项目，重启tomcat，这里面需要配合shell脚本来完成

shell脚本，如下：基本的逻辑是先将原来的项目压缩，移动到备份目录，然后将修改后的项目上传到服务器对应的目录，并重启tomcat

<code>WORK_DIR=`pwd`
TOMCAT_DIR=$WORK_DIR/tomcat-dynamic-api
NOW_TIME=`date +%Y%m%d%H%M%S`
tar -jcvf $TOMCAT_DIR/webapps/dynamicAPI.tar.$NOW_TIME $TOMCAT_DIR/webapps/dynamicAPI
mv $TOMCAT_DIR/webapps/dynamicAPI.tar.$NOW_TIME $TOMCAT_DIR/backup/
mv $TOMCAT_DIR/backup/dynamicAPI.war $TOMCAT_DIR/webapps/
rm -rf $TOMCAT_DIR/webapps/dynamicAPI
kill -9 `ps aux | grep tomcat-dynamic-api | grep -v grep | awk '{print $2}'` &amp;&amp; $TOMCAT_DIR/bin/startup.sh</code>

maven配置

   
    <profiles>
        <profile>
            <id>local</id>
            <properties>
                <env>local</env>
            </properties>
        </profile>
        <profile>
            <id>product156</id>
            <!--
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
             -->
            <properties>
                <env>product_156</env>
            </properties>
        </profile>
        <profile>
            <id>product169</id>
            <properties>
                <env>product_169</env>
            </properties>
        </profile>
        <profile>
            <id>backup148</id>
            <properties>
                <env>backup_148</env>
            </properties>
            <build>
                <resources></resources>
            </build>
        </profile>

        <profile>
            <id>test157</id>
            <properties>
                <env>test_157</env>
            </properties>
        </profile>
        <profile>
            <id>test169</id>
            <properties>
                <env>test_169</env>
            </properties>
        </profile>

    </profiles>
    <!-- 配置文件 -->

    <build>
        <finalName>dynamicAPI</finalName>
        <extensions>
            <extension>
                <groupId>org.apache.maven.wagon</groupId>
                <artifactId>wagon-ssh</artifactId>
                <version>2.8</version>
            </extension>
        </extensions>
        <resources>
            <resource>
                <directory>src/main/resources/${env}</directory>
            </resource>
        </resources>
        <testSourceDirectory>src/test/java</testSourceDirectory>
        <testResources>
            <testResource>
                <directory>src/test/resources</directory>
            </testResource>
        </testResources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <webResources>
                        <resource>
                            <directory>WebContent</directory>
                        </resource>
                        <resource>
                            <directory>libs/</directory>
                            <targetPath>WEB-INF/lib</targetPath>
                            <includes>
                                <include>**/*.jar</include>
                            </includes>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.16</version>
                <configuration>
                    <skipTests>true</skipTests>
                    <junitArtifactName>junit:junit</junitArtifactName>
                    <argLine>-Dfile.encoding=UTF-8</argLine>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <excludes>
                        <exclude>product_156/**</exclude>
                        <exclude>product_169/**</exclude>
                        <exclude>test_157/**</exclude>
                        <exclude>*.properties</exclude>
                        <exclude>*.xml</exclude>
                    </excludes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.6</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>versions-maven-plugin</artifactId>
                <version>2.1</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.8</version>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <overWriteReleases>false</overWriteReleases>
                            <overWriteSnapshots>false</overWriteSnapshots>
                            <overWriteIfNewer>true</overWriteIfNewer>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

上次说了使用RxJava并行提升API效率，但是如何避免项目中一个服务拖慢整体的性能？hystrix优雅的解决了这个问题。

先贴个图，网上找的，我觉得这个图就可以说明问题了

4176761192

当依赖服务A挂了，直接就会影响到整个服务的性能，如果连接一直被A暂用，最终将导致服务发生雪崩

所以我们要保证核心服务的稳定，其他非核心的服务可以不那么重要，即使出现了错误数据可以丢弃或不用保证实时准确，再以SOA项目中的getDynamicInfo为例，如下：

getFlight为核心的业务，必须要获取到数据，获取不到那就整个服务不可用了

getEntryCard、getPlane、getRefund、getWeather、getPortaitUser等方法为非核心业务，我们允许其数据丢失的情况，要保证整个服务的可用

首先我们需要把这些服务使用hystrix分离出来，先对这几个服务做先分组：

pydyn：getEntryCard、getPlane、getRefund、getWeather

portrait：getPortaitUser

Maven配置

	<dependency>
	  <groupId>com.netflix.hystrix</groupId>
	  <artifactId>hystrix-core</artifactId>
	  <version>1.5.8</version>
	</dependency>

以getEntryCard服务为例，继承HystrixCommand<T>，重写run方法

public class GetEntryCardCommand extends HystrixCommand<String>{

	private String arrCode;
        private GetEntryCardService service;

	public GetEntryCardCommand(String arrCode) {
		super(setter());
		this.arrCode = arrCode;
	}

	private static Setter setter() {
		return PySetter.setter().andCommandKey(HystrixCommandKey.Factory.asKey("getEntryCard"));
	}

	@Override
	protected String run() throws Exception {
		/ TODO Auto-generated method stub
		return service.getEntryCardCity(arrCode);
	}

	@Override
	protected String getFallback() {
		return service.getFromCache(arrCode);
	}

}

run方法要执行的业务逻辑，如果出现异常则会调用getFallback方法。

public class PySetter {

	public static Setter setter() {
		/ 服务分组
		HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey("pydyn");
		/ 服务标识
		/HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey("getEntryCard");
		/ 线程池名称
		HystrixThreadPoolKey threadPoolKey = HystrixThreadPoolKey.Factory.asKey("pydyn-pool");
		/ 线程配置
		HystrixThreadPoolProperties.Setter threadPoolProperties = HystrixThreadPoolProperties.Setter()
				.withCoreSize(10)
				.withKeepAliveTimeMinutes(5)
				.withMaxQueueSize(Integer.MAX_VALUE)
				.withQueueSizeRejectionThreshold(10000);

		/命令属性配置
		HystrixCommandProperties.Setter commandProperties = HystrixCommandProperties.Setter()
				.withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD)
                                .withExecutionIsolationThreadInterruptOnTimeout(true).withExecutionTimeoutInMilliseconds(3000) /设置超时3秒自动熔断
				.withCircuitBreakerErrorThresholdPercentage(30);/失败率达到30%自动熔断

		return HystrixCommand.Setter
				.withGroupKey(groupKey)
				/.andCommandKey(commandKey)
				.andThreadPoolKey(threadPoolKey)
				.andThreadPoolPropertiesDefaults(threadPoolProperties)
				.andCommandPropertiesDefaults(commandProperties);
	}

}

以上是对服务的线程池熔断配置

HystrixCommandGroupKey：服务分组，以上pydyn分组就包括4个服务，必填选项

HystrixCommandKey：服务的名称，唯一标识，如果不配置，则默认是类名

HystrixThreadPoolKey：线程池的名称，相同线程池名称的线程池是同一个，如果不配置，默认为分组名

HystrixThreadPoolProperties：线程池的配置，coreSize配置核心线程池的大小，maxQueueSize线程池队列的最大大小，queueSizeRejectionThreshold，限制当前队列的大小，实际队列大小由这个参数决定，即到达队列里面条数到达10000，则都会被拒绝。

HystrixCommandProperties：配置命令的一些参数，如executionIsolationStrategy，配置执行隔离策略，默认是使用线程隔离，THREAD即为线程池隔离，ExecutionIsolationThreadInterruptOnTimeout和ExecutionTimeoutInMilliseconds配置了启用超时和最大执行时间，这里为3s，circuitBreakerErrorThresholdPercentage失败率配置，默认为50%，这里配置的为30%，即失败率到达30%触发熔断

接下来就是调用GetEntryCardCommand获取数据

String result = new GetEntryCardCommand(request.getArrCode()).execute();

我使用的是阻塞的方式获取，当然也可以使用异步的方法，得到Future对象，使用

Future<String> = new GetEntryCardCommand(request.getArrCode()).queue();

其他getPlane、getRefund、getWeather方法同GetEntryCardCommand类，

getPortaitUser也一样，只需要更改下自己的分组为portait，线程池名称，并配置自己的线程池参数

好了，这样就实现了多个服务之间的隔离和熔断，不同的服务分组使用不同的线程池，即使getDynamicInfo并发量突然剧增，也不会对getPlane、getRefund、getWeather等产生影响

下面来说说对服务的监控，hystrix已经帮我们实现了数据的记录，只需要安装他们的管理后台就可以查看数据，他们家有2个监控后台：hystrix-dashboard和Turbine，第一个是监控单个项目的日志，第二个可以把多个项目的日志聚合在一起

hystrix-dashboard监控：

maven配置：

	 <dependency>  
	     <groupId>com.netflix.hystrix</groupId>  
	     <artifactId>hystrix-metrics-event-stream</artifactId>  
	     <version>1.1.2</version>  
 	</dependency>

web.xml配置

    <servlet>  
	    <display-name>HystrixMetricsStreamServlet</display-name>  
	    <servlet-name>HystrixMetricsStreamServlet</servlet-name>  
	    <servlet-class>com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet</servlet-class>  
	</servlet>  
	<servlet-mapping>  
	    <servlet-name>HystrixMetricsStreamServlet</servlet-name>  
	    <url-pattern>/hystrix.stream</url-pattern>  
	</servlet-mapping>

访问/ip:port/projectName/hystrix.stream查看是否有监控数据

hystrix-dashboard：先安装hystrix-dashboard.war，下载后放入web容器（Tomcat或Jetty）中，启动容器，访问/ip:port/hystrix-dashboard，如下的界面：

最后点击Monitor Stream就可以看到数据了

(918) 577-5564

可以看到每个服务及他们的线程池使用情况

CirCuit主要监控成功的请求数，请求超时数，失败率，平均耗时、90%，99%，99.5%的耗时（将鼠标移动到对于数字位置可以看到描述）

Thread Pools主要监控线程池的配置数，线程队列的配置数，最大活跃线程

Turbine监控（将多个实例的数据聚合起来）

1）下载turbine-web-1.0.0.war，并将war放入web容器中。

2）在容器下路径为turbine-web-1.0.0/WEB-INF/classes下新建config.properties文件。

InstanceDiscovery.impl=com.netflix.turbine.discovery.ConfigPropertyBasedDiscovery
#cluster
turbine.aggregator.clusterConfig=dynamicAPI
turbine.instanceUrlSuffix=:8080/projectName/hystrix.stream
turbine.ConfigPropertyBasedDiscovery.dynamicAPI.instances=127.0.0.1,127.0.0.2

这里我配置了2个实例127.0.0.1和127.0.0.2，他会同时调用/127.0.0.1:8080/projectName/hystrix.stream和/127.0.0.2:8080/projectName/hystrix.stream，然后根据分组名，服务名，线程池名将两个实例数据合并

3）调用/ip:port/turbine-web-1.0.0/turbine.stream?cluster=dynamicAPI，即可查看到聚合的数据

4）打开hystrix-dashboard配置turbine

点击Monitor Stream即可查看到两个实例监控的数据

(541) 896-5673

参考资料：

/tech.lede.com/2017/06/15/rd/server/hystrix/

/www.cnblogs.com/java-zhao/archive/2016/09/01/5831002.html

JAVA通过自带的垃圾回收机制来管理内存，但对于项目的内存分析也要了解，比如项目的内存使用情况，何时回收？或出现内存泄露如何排查？

首先看看JVM内存分配图：

如上图，jvm包含了堆、本地方法栈，

堆上存放新建（New）的对象，它被划为为新生代，老年代两个区域，新生代又分为伊甸园、幸存者两个区域，不同的区域存放的对象生命周期不同

说说JAVA中几种内存溢出的情况：

1，JVM堆溢出（java.lang.OutOfMemoryError: java heap space）

当生成一个新对象，JVM内存申请如下流程：

1），jvm先尝试在eden分配新对象所需的内存，若内存足够，则将对象放入eden返回

2），若内存不够，jam启动youngGC，试图将eden不活跃的对象释放掉，若释放后仍不足以分配内存，则将Eden活跃的对象放入survivor中。

3），survivor作为Eden和old的中间交换区域，若old空间足够，survivor去对象会被移动到old区，否则留在survivor区

4），当old区不够时，jvm会在old区进行fullGC，若fullGC后，survivor和old仍然无法存放从Eden复制过来的对象，则会出现“outOfMemoryError: java heap space”

解决方法：加大堆内存的大小，通过设置-Xms（java heap初始化大小，默认是物理内存1/64） -Xmx（java heap的最大值） -Xmn（新生代heap的大小，一般为Xmx3或4分之一，注：增加新生代后会减少老年代的大小）

2，方法区内存溢出（java.lang.OutMemoryError: permGen space）

方法区主要是用来存放类信息，常量、静态变量等，所以程序中类加载过多（引入第三方包），或者过多使用反射、cglib这种动态代理，就可能导致该区域内存溢出

解决方法：通过设置-XX:PermSize（内存永久区初始值）和-XX:MaxPerSize（内存永久区最大值）的大小

3，线程栈溢出（java.lang.StackOverflowError）

线程栈是线程独有的一块内存区域，所以线程栈溢出必定是线程运行是出现错误，一般是递归太深，或者方法层级调用太深引起的

解决方法：设置栈区的大小，通常栈的大小是1-2M，可通过-Xss设置线程的栈的大小，jdK5以后每个栈默认大小为1M。

下面针对线上的某个项目，查看它是否出现内存溢出的情况

1，如何查看项目的内存使用情况？

jmap -heap pid

Attaching to process ID 64909, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.91-b14

using thread-local object allocation.
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 2147483648 (2048.0MB)
   NewSize                  = 44564480 (42.5MB)
   MaxNewSize               = 715653120 (682.5MB)
   OldSize                  = 89653248 (85.5MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 31457280 (30.0MB)
   used     = 12660000 (12.073516845703125MB)
   free     = 18797280 (17.926483154296875MB)
   40.24505615234375% used
From Space:
   capacity = 1572864 (1.5MB)
   used     = 1179648 (1.125MB)
   free     = 393216 (0.375MB)
   75.0% used
To Space:
   capacity = 9437184 (9.0MB)
   used     = 0 (0.0MB)
   free     = 9437184 (9.0MB)
   0.0% used
PS Old Generation
   capacity = 40894464 (39.0MB)
   used     = 4514768 (4.3056182861328125MB)
   free     = 36379696 (34.69438171386719MB)
   11.040046887520033% used

查看Java内存的分配情况及新生代、老年代内存的使用情况，确定是否内存分配过小？

2，判断是否出现内存泄露

jstat -gcutil pid 2000

上面命令表示每隔2秒打印出GC的使用回收情况，若FGC很多很可能出现了内存泄露

3，查看占用内存最多的对象

jmap -histo:live pid | more

按使用大小进行了排序，重点查看排在前面的对象，看是否程序写的有问题。

另外可以将jvm的堆内存导出来分析，使用

jmap -dump:format=b,file=dynamicapi.hprof pid

使用java vistual工具分析，jdk自带了jvisualvm就可以进行内存分析，执行命令：

进入jkd的bin目录，执行jvisualvm

点击文件->装入，选择堆内存文件，即可看到堆中类的使用情况