1. MQ asynchronous data acquisition
1) Using MQ asynchronization to break away from the main service and shorten the response time of the main service.
2) Using MQ asynchronous data storage operation to reduce the pressure of the main business server.
3) Storage uses es to support big data query and improve query efficiency.
4) In process asynchronous MQ message sending operation can be realized by using Google thread bus or spring @ async
2. The design is as follows
1. Questions
The program connection to the database is abnormal, as follows:
Could not create connection to database server. Attempted reconnect 3 times. Giving 2. Solutions
I tried a variety of solutions, and finally realized: MySQL connector- java.jar Inconsistent with the latest database version. The database is the latest version of 8
0.19，mysql-connector- java.jar It’s 5.0.6.
Solution: MySQL connector- java.jar Keep the same version number as the database.
The POM file is as follows, please check and modify the version by yourself; some versions are compatible, but it is better to keep them unified.
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
1. Scene
Jenkins one click deployment has not been installed under Linux.
2. Operation process
① Manual upload.
② Delete history code.
③ Unzip the war package.
④ Delete the war package.
⑤ Restart Tomcat.
⑥ Show logs.
3. Process disassembly
1) Use the RZ command to upload the war package.
2) Use the following command to complete the rest of the work in one go. Note: the last line is reserved for carriage return and line feed to ensure that the command will be executed.
cd /opt/codes/portal-system
rm -rf META-INF
rm -rf WEB-INF
rm -rf importDataModel.xlsx
unzip portal-system-1.0.0. RELEASE.war
rm -rf portal-system-1.0.0. RELEASE.war
/opt/server/tomcat_ portal_ system/bin/ restart.sh
3） restart.sh Please refer to the previous blog post for the script.
4. Incremental design scheme
cd /opt/codes/portal-system/WEB-INF/classes
rz
rm -r com
unzip com.zip
rm -rf com.zip
/opt/server/tomcat_ portal_ system/bin/ restart.sh
#tail -f /opt/server/tomcat_ portal_ system/logs/ info.log
1、 What is a service gateway
Service gateway = route forwarding + filter
1. Route forwarding: receive all external requests and forward them to the back-end micro service.
2. Filter: in the service gateway, a series of crosscutting functions can be completed, such as permission verification, current limiting and monitoring. All these can be completed through the filter (in fact, routing and forwarding are also realized through the filter).
2、 Why a service gateway is needed
the above crosscutting function (taking permission verification as an example) can be written in three places:
1) each service is implemented by itself [not recommended]
2) write to a public service, and then all other services depend on this service [not recommended]
3) write it to the prefilter of the service gateway, and all requests come to check the permission [recommended]
First, the disadvantages are too obvious to use;
Second, compared with the first point, the code development is not redundant, but there are two disadvantages:
(1) because each service introduces this public service, it is equivalent to introducing the same permission verification code in each service, which increases the jar package size of each service for no reason. Especially for the deployment scenario using docker image, the smaller the jar, the better;
② Since this public service is introduced into every service, it may be difficult for us to upgrade this service in the future. Moreover, the more functions the public service has, the more difficult it will be to upgrade. Suppose we change the way of permission verification in public service. If we want all services to use the new way of permission verification, we need to re package all previous services , compile the deployment.
The service gateway can solve this problem
So, need service gateway!!!
3、 Service gateway technology selection
After the introduction of service gateway, the microservice architecture is as above, including three parts: service gateway, open service and service.
1. Overall process:
The service gateway, open service and service are registered in the registry when they are started; the user requests the gateway directly, and the gateway performs intelligent routing and forwarding (including service discovery and load balancing) to the open service, which includes permission verification, monitoring, current limiting and other operations. The open service aggregates the internal service response, returns it to the gateway, and the gateway returns it to the user
2. Points for attention in introducing gateway
With the addition of gateway and one more layer of forwarding (originally, the user requested to directly access the open service), the performance will decline (but the decline is not big. Generally, the performance of gateway machine will be very good, and the access between gateway and open service is usually intranet access, which is very fast); single point problem of gateway: there must be a single point in the whole network call process, which may be Gateway, nginx, DNS server, etc. To prevent gateway single point, you can hang another nginx in front of the gateway layer. The performance of nginx is very high, and it will not hang basically. After that, the gateway service can continuously add machines. However, such a request is forwarded twice, so the best way is to deploy the gateway single point service on a powerful machine (estimate the configuration of the machine through pressure test). Moreover, the performance comparison between nginx and zuul is similar according to the experiment done by a foreign friend. Zuul is an open source framework for gateway of Netflix, and the gateway should be fully implemented Light weight.
3. Basic functions of service gateway
Intelligent routing: receive all external requests and forward them to the external service open service of the back end;
Note: we only forward external requests, and requests between services do not go through the gateway. This means that full link tracking, internal service API monitoring, fault tolerance of calls between internal services, and intelligent routing cannot be completed in the gateway. Of course, all service calls can go through the gateway, and almost all functions can be integrated into the gateway, but in this case, the gateway’s pressure can be reduced It’s going to be very heavy. Permission verification: only the user’s request to the open service is verified, and the internal request of the service is not verified. Is it necessary to verify the request inside the service?API monitoring: only monitor the requests passing through the gateway and some performance indicators of the gateway itself (for example, GC, etc.); current limiting: cooperate with the monitoring to carry out current limiting operation; API log unified collection: similar to an aspect aspect aspect, record the relevant log when the interface enters and goes out… Follow up supplement
The above functions are the basic functions of the gateway, and the gateway can also realize the following functions:
A | B test: a | B test is a relatively large thing, including background experiment configuration, data burial point (see conversion rate) and streaming engine. In the service gateway, the streaming engine can be realized, but in fact the streaming engine will call internal services, so if it is in accordance with the architecture in the figure above, the streaming engine should be in the open service rather than in the service gateway…. Follow up supplement
4. Technology selection
The author is going to build a lightweight service gateway
Development language: java + groovy, the advantage of groovy is that the gateway service can dynamically add filter to achieve some functions without restart; microservice basic framework: springboot; gateway basic component: Netflix zuul; service registry: consult; permission verification: JWT; API monitoring: Prometheus + grafana; API unified log collection: logback+ Elk; stress test: JMeter;… Follow up supplement
In the follow-up introduction, will gradually introduce each knowledge point, and complete a lightweight service gateway!!!
1. Principle
Lock synchronization lock
Signal() and await() of condition
2. Code examples
package com.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TasksTestLock extends Thread {
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
private static int num = 1;
private int id;
public TasksTestLock(int id) {
this.id = id;
}
@Override
public void run() {
while (num <= 12) {
lock.lock();
System.out.println("Thread" + id + " num:" + num);
num++;
condition.signal();
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
}
}
public static void main(String[] args) {
Thread thread0 = new TasksTestLock(0);
Thread thread1 = new TasksTestLock(1);
ExecutorService exec = Executors.newFixedThreadPool(3);
exec.submit(thread0);
exec.submit(thread1);
exec.shutdown();
}
}3. Output results
1. Principle
Synchronized thread synchronization
Notify() calls up the thread
The wait() thread waits
2. Code examples
package com.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TasksTestSync extends Thread {
private static Integer num = 0;
private int id;
public TasksTestSync(int id) {
this.id = id;
}
@Override
public void run() {
while (num < 12) {
synchronized (TasksTestSync.class) {
num = num + 1;
System.out.println("thread_" + id + " num:" + num);
TasksTestSync.class.notify();
try {
TasksTestSync.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
Thread thread0 = new TasksTestSync(0);
Thread thread1 = new TasksTestSync(1);
ExecutorService exec = Executors.newFixedThreadPool(3);
exec.submit(thread0);
exec.submit(thread1);
exec.shutdown();
}
}3. Implementation results
1. Reduce cost and improve efficiency
Reduce the time of thread creation and destruction and the overhead of system resources;
At the same time, it improves the response speed of the system. When a new task arrives, it can be executed immediately by reusing the existing thread without waiting for the creation of a new thread.
2. Improve the manageability of threads
It is convenient to control the number of concurrent threads. Unlimited thread creation may lead to excessive memory consumption, resulting in oom, and will cause excessive CPU switching. There is a time cost for CPU switching threads: it is necessary to keep the scene of the current thread and restore the scene of the thread to be executed.
It can allocate, tune and monitor threads in a unified way, so as to improve the response speed, and provide more powerful functions, such as delaying and timing thread pool.
1. Scene
Nginx implements the separation of front and back end, and the reverse proxy of service cluster.
2. Nginx configuration instance
upstream portal-system {
server 127.0.0.1:8061 max_fails=3 fail_timeout=30s;
server 172.31.88.30:8061 max_fails=3 fail_timeout=30s;
}
server {
listen 80;
server_name 47.102.168.177;
root /opt/pages/dispatch-portal-system/;
location/{
proxy_set_header Host $host:$server_port;
proxy_pass http://portal-system;
}
location /images/ {
alias /opt/images/dispatch-portal-system/;
}
location /favicon.ico {
root /opt/images/dispatch-portal-system/;
}
location /api/user/updateImage/ {
proxy_set_header Host $host:$server_port;
proxy_pass http://127.0.0.1:8061/;
}
location =/{
root /opt/pages/dispatch-portal-system/;
add_header Cache-Control "no-cache, no-store";
}
location /index.html {
root /opt/pages/dispatch-portal-system/;
add_header Cache-Control "no-cache, no-store";
}
location /static/ {
root /opt/pages/dispatch-portal-system/;
}
}
1. Scene
Two servers are deployed with XXL job respectively to build a high availability cluster
Provide easy request URL
2. Nginx configuration
upstream xxl-jobs {
server 192.168.30.01:9500 max_fails=3 fail_timeout=30s;
server 192.168.30.02:9500 max_fails=3 fail_timeout=30s;
}
server {
listen 8888;
server_name localhost;
location/{
proxy_pass http://xxl-jobs;
index index.html index.htm;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
1. Printing stack information using jstack command
jstack -l pid >> thread.txt
Parameter: – l long lists to print out additional lock information. Jstack – L PID can be used to observe the lock holding status when a deadlock occurs
Examples
jstack -l 7052 >> thread.txt
2. Analyze stack information
take thread.txt Download it locally and use IBM thread and monitor dump analyzer for Java to open the analysis
1. Problem scenario
Project update, upload the entire jar package, too large, resulting in long upload time, update or upgrade too slow.
2. Solutions
1) Store jars that are not updated frequently in a separate folder LIBS.
2) Frequently updated jars are typed as one jar.
3、 pom.xml to configure
1) The final jar package contains the updated jar package
2) Folder LIBS kicks out jars that are often updated
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>prepare-package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/libs</outputDirectory>
<overWriteIfNewer>true</overWriteIfNewer>
<includeScope>runtime</includeScope>
<excludeGroupIds>com.mp,com.mp.common.spring,com.mp.common.util</excludeGroupIds>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<layout>ZIP</layout>
<includes>
<include>
<groupId>com.mp</groupId>
<artifactId>mp-dispatch-service-api</artifactId>
</include>
<include>
<groupId>com.mp.common.spring</groupId>
<artifactId>common-spring-jpa</artifactId>
</include>
<include>
<groupId>com.mp.common.spring</groupId>
<artifactId>common-spring-base</artifactId>
</include>
<include>
<groupId>com.mp.common.util</groupId>
<artifactId>common-util</artifactId>
</include>
</includes>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
<goal>build-info</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
1. Scene
Mysql database in the pure Intranet environment, no public IP, no VPN.
2. Programme
Install nginx on a server with public IP and in the same Intranet environment with MySQL service to realize the routing and forwarding of MySQL access.
3. Nginx installation
Nginx version needs 1.9 or above. Nginx not only implements HTTP reverse proxy, but also supports TCP reverse proxy.
1) When compiling nginx, you need to add the parameter — with stream to load NGX_ stream_ core_ Module
Examples
./configure –prefix=/opt/software/nginx –with-http_ stub_ status_ module –with-http_ ssl_ module –with-stream –with-stream_ ssl_ module –with-pcre=/usr/local/src/pcre-8.35
4. Nginx configuration file nginx.conf
Monitor port 3307 with public IP server, and jump to port 3306 of 172.31.88.27.
Special note: stream should be in the same level directory as HTTP
stream {
upstream mysql3306 {
hash $remote_addr consistent;
server 172.31.88.27:3306 weight=5 max_fails=3 fail_timeout=30s;
}
server {
listen 3307;
proxy_connect_timeout 10s;
proxy_timeout 200s;
proxy_pass mysql3306;
}
}