java复制代码EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap server = new ServerBootstrap();
server.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)

java复制代码    serverBootstrap.bind(port).addListener(future -> {
        if (future.isSuccess()) {
            System.out.println(new Date() + ": 端口[" + port + "]绑定成功!");
        } else {
            System.err.println("端口[" + port + "]绑定失败!");
        }
    });

java复制代码    public static void main(String[] args) {
        // 创建mainReactor
        NioEventLoopGroup boosGroup = new NioEventLoopGroup();
        // 创建工作线程组
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        final ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap 
                 // 组装NioEventLoopGroup 
                .group(boosGroup, workerGroup)
                 // 设置channel类型为NIO类型
                .channel(NioServerSocketChannel.class)
                // 设置连接配置参数
                .option(ChannelOption.SO_BACKLOG, 1024)
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .childOption(ChannelOption.TCP_NODELAY, true)
                // 配置入站、出站事件handler
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel ch) {
                        // 配置入站、出站事件channel
                        ch.pipeline().addLast(...);
                        ch.pipeline().addLast(...);
                    }
    });

        // 绑定端口
        int port = 8080;
        serverBootstrap.bind(port).addListener(future -> {
            if (future.isSuccess()) {
                System.out.println(new Date() + ": 端口[" + port + "]绑定成功!");
            } else {
                System.err.println("端口[" + port + "]绑定失败!");
            }
        });
}

java复制代码ctx.channel().eventLoop().execute(new Runnable() {
    @Override
    public void run() {
        //...
    }
});

java复制代码ctx.channel().eventLoop().schedule(new Runnable() {
    @Override
    public void run() {

    }
}, 60, TimeUnit.SECONDS);

xml复制代码<configuration>
    <!-- Docker 远程管理地址-->
    <dockerHost>http://192.168.5.94:2375</dockerHost>
    <!-- 添加认证信息-->
    <authConfig>
        <push>
            <!--Docker Hub 用户名-->
            <username>macrodocker</username>
            <!--Docker Hub 密码-->
            <password>xxx</password>
        </push>
    </authConfig>
    <images>
        <image>
            <!--修改镜像前缀为Docker Hub 用户名-->
            <name>macrodocker/${project.name}:${project.version}</name>
        </image>
     </images>
 </configuration>

yaml复制代码apiVersion: apps/v1
kind: Deployment
metadata:
  # 指定Deployment的名称
  name: mysql-deployment
  # 指定Deployment的标签 
  labels:
    app: mysql
spec:
  # 指定创建的Pod副本数量 
  replicas: 1
  # 定义如何查找要管理的Pod
  selector:
    # 管理标签app为mysql的Pod
    matchLabels:
      app: mysql
  # 指定创建Pod的模板
  template:
    metadata:
      # 给Pod打上app:mysql标签
      labels:
        app: mysql
    # Pod的模板规约
    spec:
      containers:
        - name: mysql
          # 指定容器镜像
          image: mysql:5.7
          # 指定开放的端口
          ports:
            - containerPort: 3306
          # 设置环境变量
          env:
            - name: MYSQL_ROOT_PASSWORD
              value: root
          # 使用存储卷
          volumeMounts:
            # 将存储卷挂载到容器内部路径
            - mountPath: /var/log/mysql
              name: log-volume
            - mountPath: /var/lib/mysql
              name: data-volume
            - mountPath: /etc/mysql
              name: conf-volume
      # 定义存储卷
      volumes:
        - name: log-volume
          # hostPath类型存储卷在宿主机上的路径
          hostPath:
            path: /home/docker/mydata/mysql/log
            # 当目录不存在时创建
            type: DirectoryOrCreate
        - name: data-volume
          hostPath:
            path: /home/docker/mydata/mysql/data
            type: DirectoryOrCreate
        - name: conf-volume
          hostPath:
            path: /home/docker/mydata/mysql/conf
            type: DirectoryOrCreate

bash复制代码kubectl apply -f mysql-deployment.yaml

bash复制代码[macro@linux-local k8s]$ kubectl get deployments
NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
mysql-deployment          1/1     1            1           38s
nginx-volume-deployment   2/2     2            2           6d5h

yaml复制代码apiVersion: v1
kind: Service
metadata:
  # 定义服务名称，其他Pod可以通过服务名称作为域名进行访问
  name: mysql-service
spec:
  # 指定服务类型，通过Node上的静态端口暴露服务
  type: NodePort
  # 管理标签app为mysql的Pod
  selector:
    app: mysql
  ports:
    - name: http
      protocol: TCP
      port: 3306
      targetPort: 3306
      # Node上的静态端口
      nodePort: 30306

bash复制代码kubectl apply -f mysql-service.yaml

bash复制代码[macro@linux-local k8s]$ kubectl get services
NAME            TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
kubernetes      ClusterIP   10.96.0.1        <none>        443/TCP          7d23h
mysql-service   NodePort    10.107.189.51    <none>        3306:30306/TCP   7s
nginx-service   NodePort    10.101.171.181   <none>        80:30080/TCP     6d2h

yaml复制代码apiVersion: apps/v1
kind: Deployment
metadata:
  name: mall-tiny-fabric-deployment
  labels:
    app: mall-tiny-fabric
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mall-tiny-fabric
  template:
    metadata:
      labels:
        app: mall-tiny-fabric
    spec:
      containers:
        - name: mall-tiny-fabric
          # 指定Docker Hub中的镜像地址
          image: macrodocker/mall-tiny-fabric:0.0.1-SNAPSHOT
          ports:
            - containerPort: 8080
          env:
            # 指定数据库连接地址
            - name: spring.datasource.url
              value: jdbc:mysql://mysql-service:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
            # 指定日志文件路径
            - name: logging.path
              value: /var/logs
          volumeMounts:
            - mountPath: /var/logs
              name: log-volume
      volumes:
        - name: log-volume
          hostPath:
            path: /home/docker/mydata/app/mall-tiny-fabric/logs
            type: DirectoryOrCreate

bash复制代码kubectl apply -f mall-tiny-fabric-deployment.yaml

bash复制代码[macro@linux-local k8s]$ kubectl get pods
NAME                                           READY   STATUS    RESTARTS   AGE
mall-tiny-fabric-deployment-8684857dff-pnz2t   1/1     Running   0          47s
mysql-deployment-5dccc96ccf-sfxvg              1/1     Running   0          25m
nginx-volume-deployment-6f6c89976d-nv2rn       1/1     Running   4          6d6h
nginx-volume-deployment-6f6c89976d-tmhc5       1/1     Running   4          6d5h
[macro@linux-local k8s]$ kubectl logs -f mall-tiny-fabric-deployment-8684857dff-pnz2t

yaml复制代码apiVersion: v1
kind: Service
metadata:
  name: mall-tiny-fabric-service
spec:
  type: NodePort
  selector:
    app: mall-tiny-fabric
  ports:
    - name: http
      protocol: TCP
      port: 8080
      targetPort: 8080
      # Node上的静态端口
      nodePort: 30180

bash复制代码kubectl apply -f mall-tiny-fabric-service.yaml

bash复制代码[macro@linux-local k8s]$ kubectl get services
NAME                       TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
kubernetes                 ClusterIP   10.96.0.1        <none>        443/TCP          7d23h
mall-tiny-fabric-service   NodePort    10.100.112.84    <none>        8080:30180/TCP   5s
mysql-service              NodePort    10.107.189.51    <none>        3306:30306/TCP   13m
nginx-service              NodePort    10.101.171.181   <none>        80:30080/TCP     6d2h

bash复制代码curl $(minikube ip):30180/swagger-ui.html

ini复制代码server {
    listen       80;
    server_name  mall-tiny.macrozheng.com; #修改域名

    location / {
        proxy_set_header Host $host:$server_port;
        proxy_pass   http://192.168.49.2:30180; #修改为代理服务地址
        index  index.html index.htm;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

}

复制代码192.168.5.94 mall-tiny.macrozheng.com

java复制代码/**
 * <p>
 * 便于使用，将所有的工具方法都集中在此，包含：
 * 1. 执行 HTTP POST 请求，返回执行结果的 String
 * 2. 创建签名（为下单数据创建）
 * 3. 创建签名（为 APP 创建）
 * 4. 检验签名
 * 5. 读取 HTTP Request 内容
 * 6. 读取 HTTP Response 内容
 * 7. 将 Map 转化为 Xml
 * 8. 将 Xml 转化为 Map
 * 9. 生成 32 位随机字符串
 * 10. MD5 签名
 */
public class WxUtils {

    //APPID  微信开放平台 appid
    public static final String APPID = "xxx";

    //MCH_ID 微信商户平台  商户 mch_id
    public static final String MCH_ID = "xxx";

    //NOTIFY_URL  回调通知地址(接收微信支付异步通知回调地址，通知url必须为直接可访问的url，不能携带参数。)
    public static final String NOTIFY_URL = "xxx";
   
    //API_KEY 微信商户平台密钥
    public static String API_KEY = "xxx";

    // 下单 API 地址
    public static final String PLACE_URL = "https://api.mch.weixin.qq.com/pay/unifiedorder";


    /**
     * 1.请求方式
     * @param requestUrl
     * @param outputStr
     * @return
     */
    public static String httpsRequest(String requestUrl,String outputStr) {
        try {
            URL url = new URL(requestUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();

            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            conn.setRequestMethod("POST");
            //conn.setRequestProperty("content-type", "application/x-www-form-urlencoded");
            conn.setRequestProperty("content-type", "text/xml;charset=utf-8");
            // 当outputStr不为null时向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }
            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            StringBuilder buffer = new StringBuilder();
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            conn.disconnect();
            return buffer.toString();
        } catch (ConnectException ce) {
            System.out.println("连接超时：{}"+ ce);
        } catch (Exception e) {
            System.out.println("https请求异常：{}"+ e);
        }
        return null;
    }

    /**  2
     * 第一次签名
     *
     * @param parameters 数据为服务器生成，下单时必须的字段排序签名
     * @param key
     * @return
     */
    public static String createSign(SortedMap<String, Object> parameters, String key) {
        StringBuffer sb = new StringBuffer();
        Set es = parameters.entrySet();//所有参与传参的参数按照accsii排序（升序）
        Iterator it = es.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String k = (String) entry.getKey();
            Object v = entry.getValue();
            if (null != v && !"".equals(v)
                    && !"sign".equals(k) && !"key".equals(k)) {
                sb.append(k + "=" + v + "&");
            }
        }
        sb.append("key=" + key);
        return encodeMD5(sb.toString());
    }

    /** 3
     * 第二次签名
     *
     * @param result 数据为微信返回给服务器的数据（XML 的 String），再次签名后传回给客户端（APP）使用
     * @param key    密钥
     * @return
     * @throws IOException
     */
    public static Map createSign2(String result, String key) throws IOException {
        SortedMap<String, Object> map = new TreeMap<>(transferXmlToMap(result));
        String returnCode = (String)map.get("return_code");
        if(StringUtils.equalsIgnoreCase("success",returnCode)){
            String resultCode = (String)map.get("result_code");
            Map app = new HashMap();
            app.put("appid", map.get("appid"));//应用ID
            app.put("partnerid", map.get("mch_id"));//商户号
            app.put("prepayid", map.get("prepay_id"));//预支付交易会话ID
            app.put("package", "Sign=WXPay");// 固定字段，保留，不可修改
            app.put("noncestr", map.get("nonce_str"));//随机字符串
            app.put("timestamp", new Date().getTime() / 1000);  //时间戳  时间为秒，JDK 生成的是毫秒，故除以 1000
            app.put("sign", createSign(new TreeMap<>(app), key));//签名
            if(StringUtils.equalsIgnoreCase("success",resultCode)){
                app.put("tradestate",map.get("trade_state"));
            }
            System.out.println(app+"-------------");
            return app;
        }
        return null;
    }

    /** 4
     * 验证签名是否正确
     *
     * @return boolean
     * @throws Exception
     */
    public static boolean checkSign(SortedMap<String, Object> parameters, String key) throws Exception {
        String signWx = parameters.get("sign").toString();
        if (signWx == null) return false;
        parameters.remove("sign"); // 需要去掉原 map 中包含的 sign 字段再进行签名
        String signMe = createSign(parameters, key);
        return signWx.equals(signMe);
    }

    /**  5
     * 读取 request body 内容作为字符串
     *
     * @param request
     * @return
     * @throws IOException
     */
    public static String readRequest(HttpServletRequest request) throws IOException {
        InputStream inputStream;
        StringBuffer sb = new StringBuffer();
        inputStream = request.getInputStream();
        String str;
        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
        while ((str = in.readLine()) != null) {
            sb.append(str);
        }
        in.close();
        inputStream.close();
        return sb.toString();
    }

    /**  6
     * 读取 response body 内容为字符串
     */
    public static String readResponse(HttpResponse response) throws IOException {
        BufferedReader in = new BufferedReader(
                new InputStreamReader(response.getEntity().getContent()));
        String result = new String();
        String line;
        while ((line = in.readLine()) != null) {
            result += line;
        }
        return result;
    }

    /**  7
     * 将 Map 转化为 XML
     *
     * @param map
     * @return
     */
    public static String transferMapToXml(SortedMap<String, Object> map) {
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        for (String key : map.keySet()) {
            sb.append("<").append(key).append(">")
                    .append(map.get(key))
                    .append("</").append(key).append(">");
        }
        return sb.append("</xml>").toString();
    }


    /**  8
     * 将 XML 转化为 map
     *
     * @param strxml
     * @return
     * @throws JDOMException
     * @throws IOException
     */
    public static Map transferXmlToMap(String strxml) throws IOException {
        strxml = strxml.replaceFirst("encoding=\".*\"", "encoding=\"UTF-8\"");
        if (null == strxml || "".equals(strxml)) {
            return null;
        }
        Map m = new HashMap();
        InputStream in = new ByteArrayInputStream(strxml.getBytes("UTF-8"));
        SAXBuilder builder = new SAXBuilder();
        Document doc = null;
        try {
            doc = builder.build(in);
        } catch (JDOMException e) {
            throw new IOException(e.getMessage()); // 统一转化为 IO 异常输出
        }
        // 解析 DOM
        Element root = doc.getRootElement();
        List list = root.getChildren();
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Element e = (Element) it.next();
            String k = e.getName();
            String v = "";
            List children = e.getChildren();
            if (children.isEmpty()) {
                v = e.getTextNormalize();
            } else {
                v = getChildrenText(children);
            }
            m.put(k, v);
        }
        //关闭流
        in.close();
        return m;
    }

    /**  9
     * 辅助 transferXmlToMap 方法递归提取子节点数据
      * @param children
     * @return
     */
    private static String getChildrenText(List<Element> children) {
        StringBuffer sb = new StringBuffer();
        if (!children.isEmpty()) {
            Iterator<Element> it = children.iterator();
            while (it.hasNext()) {
                Element e = (Element) it.next();
                String name = e.getName();
                String value = e.getTextNormalize();
                List<Element> list = e.getChildren();
                sb.append("<" + name + ">");
                if (!list.isEmpty()) {
                    sb.append(getChildrenText(list));
                }
                sb.append(value);
                sb.append("</" + name + ">");
            }
        }
        return sb.toString();
    }


    /**  10
     * 生成 32 位随机字符串，包含：数字、字母大小写
     *
     * @return
     */
    public static String gen32RandomString() {
        char[] dict = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
                'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
        StringBuffer sb = new StringBuffer();
        Random random = new Random();
        for (int i = 0; i < 32; i++) {
            sb.append(String.valueOf(dict[(int) (Math.random() * 62)]));
        }
        return sb.toString().toUpperCase();
    }


    /**  11
     * MD5 签名
     *
     * @param str
     * @return 签名后的字符串信息
     */
    public static String encodeMD5(String str) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            byte[] inputByteArray = (str).getBytes();
            messageDigest.update(inputByteArray);
            byte[] resultByteArray = messageDigest.digest();
            return byteArrayToHex(resultByteArray);
        } catch (NoSuchAlgorithmException e) {
            return null;
        }
    }

    /**  12
     * 辅助 encodeMD5 方法实现
     * @param byteArray
     * @return
     */
    private static String byteArrayToHex(byte[] byteArray) {
        char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] resultCharArray = new char[byteArray.length * 2];
        int index = 0;
        for (byte b : byteArray) {
            resultCharArray[index++] = hexDigits[b >>> 4 & 0xf];
            resultCharArray[index++] = hexDigits[b & 0xf];
        }
        // 字符数组组合成字符串返回
        return new String(resultCharArray);
    }
}

typescript复制代码package com.xp.service.order.impl;

@Service
public class WXPayServiceImpl implements WXPayService {

    @Override
    public Map pay(List<OrderInfo> list, Integer userId, List<UserCoupon>couponList,String ipAddress){
        try {
            SortedMap<String, Object> parameters = new TreeMap<>();
            parameters.put("appid", WxUtils.APPID);//应用ID
            parameters.put("body", "微信支付");//商品描述
            parameters.put("mch_id", WxUtils.MCH_ID);//商户号
            parameters.put("nonce_str", WxUtils.gen32RandomString());//随机字符串 不长于32位
            parameters.put("notify_url", WxUtils.NOTIFY_URL);//通知地址
            //parameters.put("device_info", "WEB"); //设备号  默认"WEB"
            parameters.put("out_trade_no", "唯一订单号");//商户订单号
            parameters.put("spbill_create_ip", ipAddress);//终端IP
            parameters.put("total_fee", "0.01"); // 总金额
            parameters.put("trade_type", "APP");//交易类型
            parameters.put("sign", WxUtils.createSign(parameters,WxUtils. API_KEY)); //签名 sign 必须在最后
            String requestXML = WxUtils.transferMapToXml(parameters);
            String result = WxUtils.httpsRequest(WxUtils.PLACE_URL, requestXML); // 执行 HTTP 请求，获取接收的字
            return WxUtils.createSign2(result, WxUtils.API_KEY);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public String notify(HttpServletRequest request, HttpServletResponse response){
        try {
            // 预先设定返回的 response 类型为 xml
            response.setHeader("Content-type", "application/xml");
            // 读取参数，解析Xml为map
            Map<String, String> map = WxUtils.transferXmlToMap(WxUtils.readRequest(request));
            // 转换为有序 map，判断签名是否正确
            boolean isSignSuccess = WxUtils.checkSign(new TreeMap<String, Object>(map), WxUtils.API_KEY);
            if (isSignSuccess) {
                // 签名校验成功，说明是微信服务器发出的数据
                //String orderId = map.get("out_trade_no");
                //if (tradeService.hasProcessed(orderId)) // 判断该订单是否已经被接收处理过
                    //return success();
                // 可在此持久化微信传回的该 map 数据
                if (map.get("return_code").equals("SUCCESS")) {
                    if (map.get("result_code").equals("SUCCESS")) {
                        /**
                        *回调成功之后处理业务逻辑（比如，更新订单状态，增加积分，通知仓库发货等等。）
                        */

                        return "SUCCESS";
                    } else {
                        return "FAIL";
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "FAIL";
    }
}

java复制代码public interface Subject { // 定义代理接口
    String sayHello();
}

public class SubjectImpl implements Subject {  // 定义代理接口实现类
    @Override
    public String sayHello() {
        System.out.println(" Hello World");
        return "success";
    }
}

public class ProxyInvocationHandler implements InvocationHandler {  // 定义动态代理调用处理器
    private Object target;

    public ProxyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(" 🧱 🧱 🧱 进入代理调用处理器 ");
        return method.invoke(target, args);
    }
}

java复制代码public class ProxyTest {
    public static void main(String[] args) {
        Subject subject = new SubjectImpl();
        Subject proxy = (Subject) Proxy
                .newProxyInstance(
                        subject.getClass().getClassLoader(),
                        subject.getClass().getInterfaces(),
                        new ProxyInvocationHandler(subject));

        proxy.sayHello();
        /**
         * 打印输出如下
         * 调用处理器：🧱 🧱 🧱 进入代理调用处理器
         * 被代理实现类：Hello World
         */
    }
}

java复制代码// 装载Mysql驱动
Class.forName(driveName);
// 获取连接
con = DriverManager.getConnection(url, user, pass);
// 创建Statement
Statement state = con.createStatement();
// 构建SQL语句
String stuQuerySqlStr = "SELECT * FROM student";
// 执行SQL返回结果
ResultSet result = state.executeQuery(stuQuerySqlStr);
...

java复制代码public interface Subject {
    String sayHello();
}

public class ProxyInvocationHandler implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(" 🧱 🧱 🧱 进入代理调用处理器 ");
        return "success";
    }
}

java复制代码public class ProxyTest {
    public static void main(String[] args) {
        Subject proxy = (Subject) Proxy
                .newProxyInstance(
                        subject.getClass().getClassLoader(),
                        new Class[]{Subject.class},
                        new ProxyInvocationHandler());

        proxy.sayHello();
        /**
         * 打印输出如下
         * 调用处理器：🧱 🧱 🧱 进入代理调用处理器
         */
    }
}

java复制代码public abstract class AbstractProxy {
    abstract void sayHello();
}

AbstractProxy proxyInterface = (AbstractProxy) Proxy
        .newProxyInstance(
                ProxyTest.class.getClassLoader(),
                new Class[]{AbstractProxy.class},
                new ProxyInvocationHandler());
proxyInterface.sayHello();

bash复制代码# 当前集群中来自于上游服务的总的请求数
envoy_cluster_internal_upstream_rq{response_code_class="2xx",
	cluster_name="xds-grpc"} 7163

# 上游服务完成的请求数量
envoy_cluster_upstream_rq_completed{cluster_name="xds-grpc"} 7164
# 是SSL连接出错的数量
envoy_cluster_ssl_connection_error{cluster_name="xds-grpc"} 0

bash复制代码istio_requests_total{
  connection_security_policy="mutual_tls",
  destination_app="details",
  destination_principal="cluster.local/ns/default/sa/default",
  destination_service="details.default.svc.cluster.local",
  destination_service_name="details",
  destination_service_namespace="default",
  destination_version="v1",
  destination_workload="details-v1",
  destination_workload_namespace="default",
  reporter="destination",
  request_protocol="http",
  response_code="200",
  response_flags="-",
  source_app="productpage",
  source_principal="cluster.local/ns/default/sa/default",
  source_version="v1",
  source_workload="productpage-v1",
  source_workload_namespace="default"
} 214

bash复制代码{
"level": "info",
"time": "2019-06-11T20:57:35.424310Z",
"instance": "accesslog.instance.istio-control",
"connection_security_policy": "mutual_tls",
"destinationApp": "productpage",
"destinationIp": "10.44.2.15",
"destinationName": "productpage-v1-6db7564db8-pvsnd",
"destinationNamespace": "default",
"destinationOwner": "kubernetes://apis/apps/v1/namespaces/default/deployments/productpage-v1",
"destinationPrincipal": "cluster.local/ns/default/sa/default",
"destinationServiceHost": "productpage.default.svc.cluster.local",
"destinationWorkload": "productpage-v1",
"httpAuthority": "35.202.6.119",
"latency": "35.076236ms",
"method": "GET",
"protocol": "http",
"receivedBytes": 917,
"referer": "",
"reporter": "destination",
"requestId": "e3f7cffb-5642-434d-ae75-233a05b06158",
"requestSize": 0,
"requestedServerName": "outbound_.9080_._.productpage.default.svc.cluster.local",
"responseCode": 200,
"responseFlags": "-",
"responseSize": 4183,
"responseTimestamp": "2019-06-11T20:57:35.459150Z",
"sentBytes": 4328,
"sourceApp": "istio-ingressgateway",
"sourceIp": "10.44.0.8",
"sourceName": "ingressgateway-7748774cbf-bvf4j",
"sourceNamespace": "istio-control",
"sourceOwner": "kubernetes://apis/apps/v1/namespaces/istio-control/deployments/ingressgateway",
"sourcePrincipal": "cluster.local/ns/istio-control/sa/default",
"sourceWorkload": "ingressgateway",
"url": "/productpage",
"userAgent": "curl/7.54.0",
"xForwardedFor": "10.128.0.35"
}

![image-20210131195045721](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/41517b329119eb3bcf344d700ec01bdb3253f9fabf5c8ec60791fd000c23f68b)


项目架构
----


### 爬虫组件


![img](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/36450976cd14c5575d6cd68b70ad7314696fbba4277cb41a141553d0e6066198)


上面是爬虫系统的经典架构图，简单说下每个组件的职责：


* Spiders：每个spider负责处理一个特殊的网站，负责抽取目标网站的数据
* Scheduler：调度器从引擎接受request并将他们入队，以便之后引擎请求他们时提供给引擎
* Downloader：根据request对象去执行网络下载
* Pipeline：负责将spider抽取出来的item数据进行存储，这里我们存储在MySQL


最后我们合起来说明下爬虫流程：


1. 首先创建一个spider爬虫任务，这时候会有一个入口URL，spider从这个入口开始爬取
2. 调用Downloader组件去执行http请求下载整个页面
3. spider解析页面中的内容，将需要的内容放入item里面，同时将页面中的子URL放入Scheduler组件
4. Pipeline负责将item中的数据就行持久化存储
5. URL放入Scheduler组件，Scheduler组件会对URL进行去重，避免重复爬取
6. spider爬完当前页面后就继续从Scheduler拿URL，如果有URL则继续爬取，没有则说明所有页面都爬完了，spider任务结束


### 分布式爬虫


​ 什么是分布式爬虫？用大白话来说就是：我部署了多个爬虫模块，这几个模块可以一起来爬虫。从上面架构图的分析，只需要将Scheduler模块基于redis实现，那么所有的模块的spider只需要从redis获取URL，然后爬到新的子URL时也放入redis中，此时我们的架构已经是支持分布式爬虫了。（代码细节较多，文章篇幅有限，不展开细说了）


### 定制化爬虫


​ 对于一些页面静态化的网站，做了SEO可以直接被搜索引擎爬取的网站、没有做反爬的网站，这些网站我们是可以定制一个通用的爬虫策略来爬取，直接http请求，然后解析内容和图片等资源。而对于一些做了反爬策略的，例如分页的数据、动态渲染的网页、请求头拦截、ip高频拦截等等。对于这类网站的爬虫需要做一些定制化的逻辑，所以在架构设计上，学长提供了一个爬虫订制模板的入口，通过在代码中开发针对具体网站的定制化爬虫策略，这样就可以避开大多数的反爬规则，从而实现一个爬虫系统可以支持绝大多数的网站爬取。


### 领域模型


* DO（DataObject）：与数据库表结构一一对应，通过DAO层向上传输数据源对象
* BO（BusinessObject）：业务对象。由Service层输出的封装业务逻辑的对象
* VO（View Object）：显示层对象，通常是Web向模板渲染引擎层传输的对象


BO和VO领域模型又分为BoRequest（输入模型）、BoResponse（输出模型）、VoRequest（输入模型）、VoResponse（输出模型）


技术栈
---


前端：vue + element


后端：jdk1.8 + springboot + redis + mysql + jsoup + httpClient


权限：security+spring-session


接口设计
----


​ 整个项目接口采用的目前互联网比较流行的restful风格设计，每个接口、每个参数都有详细的文档说明。因为企业中开发必然是团队协作，必然前后端分离的开发模式，你得先把接口定义出来，然后前端可以和后端同步开发。还有一种就是对外提供接口，比如你们隔壁团队也想调用你这个服务的接口，但是你两排期是同一周，这时候你得先把接口定义出来给人家，然后大家同步开发，开发完了之后再进行联调。


![image-20210131185438111](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/5f2154335758c22f4f559fe4f70d3ab7e4ab3f80cf68046614eb1cba40ee147a)


### 运行效果


**系统登录**


![image-login](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/9298abb5ad4bd2b0fea7aeeb5f1f54e8016f1e676d4325688f78f1f78c576170)


**dashboard**


实时统计系统数据


![image-20210131185722879](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/9f8ffe78c4c02ee6a29c185327e156371ec7fd88b5df34360d1e71e2c2a99b67)


**任务管理**


页面菜单、“查询”、“创建”、“编辑”、“删除”按钮都支持单独的权限分配，这里列举了爬虫案例，“爬取百度新闻”、“爬取必应壁纸”、“爬取当当网书籍信息”、“爬取新浪新闻”


创建爬虫任务


![image-20210131190101510](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/d34d17fdffdd92e4f1dc2672f67e1f675c5987b5ef8408b4adc89329836a07bc)


![image-20210131185845528](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/3a3322373baa5fcf076c4ddff583f496e83ec64496f585c44004a125f05de6c0)


**爬取必应壁纸**


​ 很多人用必应搜索是因为喜欢必应的高清壁纸（学长就是这样的），这里演示必应壁纸的爬虫。因为必应壁纸涉及分页，这里刚好用到我们的订制模板功能，通过写一个BingTemplate模板，我们可以轻松地搞定分页数据爬虫。


​ **文明爬虫**，我们只爬了100页数据，每页的图片都在资源详情里面，非常漂亮，可以点击放大图片并下载


![bing](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/faf10b2ba99e0e4084962905677cc6e548d899bf3d8d7aee7bff8852a6bdc584)


![image (1)](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/2a02580c27e2b41301c66450745a5c06e1b1cc48e74386ff7af49f47a860ce7f)


**爬取当当网**


​ 之前学长在专栏分享过《图书管理系统》，当时为了让内容更真实，从当当网爬取了一些书籍信息，比如书名、作者、出版社、价格、简介等信息。（感兴趣的可以去专栏回顾下图书管理系统的设计和实现）


​ 订制一个当当网的爬虫模板DangDangTemplate，只须一个URL，开始我们的订制爬虫之旅。


![image-20210131192319379](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/322fd59e51103c9773142d55916b2c175df3e57e18806bd714db349369474848)


**爬取百度和新浪新闻**


​ 百度新闻和新浪新闻都比较好爬，不需要模板，直接新建任务，只需要填入一个URL，立即开始爬虫。


![image-20210131191805320](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/5e280d756fe1bbf9306725e2c1580b59aa9694695880d9de300b652d2a40badd)


![image-20210131191558471](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/02e812efb81a1345d2d28a13ecdafc700ab67220406376ef82f8ea026c9fb7f6)


**资源管理**


所有爬取到的数据都可以在资源管理界面查询到，点击“资源详情”可以看到具体的文本、图片内容，图片支持放大、下载、以及幻灯片播放


![image-20210131192636062](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/95b14029e79fc236c6995623771c842a8865a3b3befdfe77f9e515f662cc455c)


**模板管理**


​ 前面已经说过，对于有反爬策略的网站和定制化的爬虫都可以通过开发一个爬虫模板来实现，这样的设计对系统扩展性是非常好的，等于说一个爬虫系统可以爬取所有的内容。


![image-20210131192937284](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/f4f4ab0159a5669a068132019acd9c10b19d9d00a9cadb88815e935f7edc8db5)


**日志管理**


​ 日志管理默认是开给管理员的，在系统中的所有操作都会被记录，在系统出现异常时也便于管理员进行问题排查。


![image-20210131193355572](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/8be9cba1db04acdddd3c0329af4f5f30012e3b59cfaf3f59256f93a2049bbd65)


**用户管理**


​ 默认也是只有管理员拥有用户管理菜单的权限，可以新建/编辑用户、分配用户角色、禁用/启用等操作


![image-20210131193425813](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/5d8e92eab58eef36563c1f6e37e34939a95f27b2c39a39582bcca41d260b73e5)


**编辑用户信息**


​ 拥有账号编辑权限的用户可以进行编辑操作


![image-20210131193554735](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/c414f0240503f4a0a865a216ee76e8f0ce1872cb0c42c19935a85b384a21174a)


**角色管理**


​ 默认也是只有管理员拥有角色管理菜单的权限，这里的权限是细粒度到按钮权限的，每个按钮都可以进行权限管理，假如给用户只分配了任务的“查询”权限，但是这个用户是个程序员，他想通过接口请求直接访问任务修改接口，这时候后端是会权限校验的，返回“未授权”的错误码，然后前端根据“未授权”错误码会重定向到一个403页面（这也是为什么说只有前端校验是不安全的，后端也必须得校验，这在实际企业里开发也是这样的，还没有实际开发经验的学弟学妹拿个小本本记一记，哈哈哈）


![image-20210131193716723](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/e51a0488ea97141519b7c38bd48ee0705f7684d115da46dd9cabddf795dcad76)


![image-20210131193755185](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/03b1764b60696e37dccc48c0bee236cb4bc15ecc010b6a83c16960f9c08be3ba)


![image-20210109205945188](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/53ebab3e5d477ae22e8ab3a673dfa3cec17d80fa4a71e320dea82aeb36e9fc6e)


### 权限设计


​ 权限基于security和spring-session实现。权限可以分为认证和授权，认证其实就是登录，用户登录时会进行账号密码的校验，校验成功后会，会把session存入redis中。授权指的是用户是否拥有访问后端资源的权限，每个新用户在创建后都会分配角色，角色其实就是一个权限集合，这里的权限可以理解为访问后端一个个接口（资源）的权限。


​ 这里权限设计的非常灵活，细粒度到按钮级别，比如课程菜单的新增、删除、修改、查询动作，学生可能只有课程的查询权限，无法新增和修改课程，即使通过接口直接访问后端的修改或者新增接口，后端也会返回授权失败错误，因为后端每个需要权限的接口都打了权限标识，只有拥有资源权限用户才能访问。


### 日志方案


​ 日志采用lombok注解+slf4j+log4j2的实现方案，基于profile实现了多环境的日志配置，因为不同环境的日志打印策略是不一样，比如开发环境我可能需要打印到console控制台，需要debug级别的日志以便于本地开发调试，测试环境可能就需要打印到日志文件里，线上环境可能需要打印到文件的同时将日志发送到kafka然后收集到es中，这样当线上部署了多台机器后我们查日志不用一台一台机器去查日志了，因为都收集到es了，我们只需要登录kibana去搜索，这样就非常方便。这里说到的kafka+es+kibana这样一套日志解决方案也是目前互联网公司比较常用的一套解决方案。如果你动手能力够强，你可以本地搭一套kafka、es、kibana，然后只需要在配置文件中加入几行配置就实现了这么一套企业级的日志解决方案（默认是输出到日志文件）。


下面是部分关键配置，如果要配置kafka，只需要在标签中配置配置即可



```
xml复制代码    <?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN"  xmlns:xi="http://www.w3.org/2001/XInclude">
    <Properties>
        <Property name="LOG_FILE">system.log</Property>
        <Property name="LOG_PATH">./logs</Property>
        <Property name="PID">????</Property>
        <Property name="LOG_EXCEPTION_CONVERSION_WORD">%xwEx</Property>
        <Property name="LOG_LEVEL_PATTERN">%5p</Property>
        <Property name="LOG_DATE_FORMAT_PATTERN">yyyy-MM-dd HH:mm:ss.SSS</Property>
        <Property name="CONSOLE_LOG_PATTERN">%clr{%d{${LOG_DATE_FORMAT_PATTERN}}}{faint} %clr{${LOG_LEVEL_PATTERN}} %clr{${sys:PID}}{magenta} %clr{---}{faint} %clr{[%15.15t]}{faint} %clr{%-40.40c{1.}}{cyan} %clr{:}{faint} %m%n${sys:LOG_EXCEPTION_CONVERSION_WORD}
        </Property>
        <Property name="FILE_LOG_PATTERN">%d{${LOG_DATE_FORMAT_PATTERN}} ${LOG_LEVEL_PATTERN} ${sys:PID} --- [%t] %-40.40c{1.}:%L : %m%n${sys:LOG_EXCEPTION_CONVERSION_WORD}
        </Property>
    </Properties>
    <Appenders>
        <xi:include href="log4j2/file-appender.xml"/>
    </Appenders>
    <Loggers>
        <logger name="com.senior.book" level="info"/>
        <Root level="info">
            <AppenderRef ref="FileAppender"/>
        </Root>
    </Loggers>
</Configuration>

```

### 服务监控


​ 服务监控基于 Actuator + Prometheus + Grafana 实现，代码侵入很小，只需要在pom中加入依赖。数据大盘Dashboard可以自己设置，也可以去Dashboard市场下载你想要的模板，总之，这块完全是看动手能力，大家自己玩吧

xml复制代码		<!--服务监控-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>

js复制代码const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);

  // 衍生工作进程。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
  });
} else {
  // 工作进程可以共享任何 TCP 连接。
  // 在本例子中，共享的是 HTTP 服务器。
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('你好世界\n');
  }).listen(8000);

  console.log(`工作进程 ${process.pid} 已启动`);
}

js复制代码cluster.on('disconnect', (worker) => {
  console.log(`工作进程 #${worker.id} 已断开连接`);
});

js复制代码cluster.on('exit', (worker, code, signal) => {
  console.log('工作进程 %d 关闭 (%s). 重启中...',
              worker.process.pid, signal || code);
  cluster.fork();
});

js复制代码const timeouts = [];
function errorMsg() {
  console.error('连接出错');
}

cluster.on('fork', (worker) => {
  timeouts[worker.id] = setTimeout(errorMsg, 2000);
});

js复制代码cluster.on('listening', (worker, address) => {
  console.log(
    `工作进程已连接到 ${address.address}:${address.port}`);
});

js复制代码cluster.disconnect([callback])

js复制代码cluster.fork([env])

js复制代码cluster.setupMaster([settings])

js复制代码const cluster = require('cluster');
cluster.setupMaster({
  exec: 'worker.js',
  args: ['--use', 'https'],
  silent: true
});
cluster.fork(); // https 工作进程
cluster.setupMaster({
  exec: 'worker.js',
  args: ['--use', 'http']
});
cluster.fork(); // http 工作进程

js复制代码const cluster = require('cluster');

if (cluster.isMaster) {
  console.log('这是主进程');
  cluster.fork();
  cluster.fork();
} else if (cluster.isWorker) {
  console.log(`这是工作进程 #${cluster.worker.id}`);
}

js复制代码// 遍历所有工作进程。
function eachWorker(callback) {
  for (const id in cluster.workers) {
    callback(cluster.workers[id]);
  }
}
eachWorker((worker) => {
  worker.send('通知所有工作进程');
});

js复制代码cluster.on('exit', (worker, code, signal) => {
  if (worker.exitedAfterDisconnect === true) {
    console.log('这是自发退出，无需担心');
  }
});

// 杀死工作进程。
worker.kill();

js复制代码worker.send(message[, sendHandle[, options]][, callback])

js复制代码if (cluster.isMaster) {
  const worker = cluster.fork();
  worker.send('你好');

} else if (cluster.isWorker) {
  process.on('message', (msg) => {
    process.send(msg);
  });
}

java复制代码/**
 * Five在努力
 * 自定义线程池
 */
public class ThreadPool {

    /** 默认线程池中的线程的数量 */
    private static final int WORK_NUM = 5;

    /** 默认处理任务的数量 */
    private static final int TASK_NUM = 100;

    /** 存放任务 */
    private final BlockingQueue<Runnable> taskQueue;

    private final Set<WorkThread> workThreads;//保存线程的集合

    private int workNumber;//线程数量

    private int taskNumber;//任务数量

    public ThreadPool(){
        this(WORK_NUM , TASK_NUM);
    }

    public ThreadPool(int workNumber , int taskNumber) {
        if (taskNumber<=0){
            taskNumber = TASK_NUM;
        }
        if (workNumber<=0){
            workNumber = WORK_NUM;
        }
        this.taskQueue = new ArrayBlockingQueue<Runnable>(taskNumber);
        this.workNumber = workNumber;
        this.taskNumber = taskNumber;

        workThreads = new HashSet<>();

        //工作线程准备好了
        //启动一定数量的线程数，从队列中获取任务处理
        for (int i=0;i<workNumber;i++) {
            WorkThread workThread = new WorkThread("thead_"+i);
            workThread.start();
            workThreads.add(workThread);
        }
    }

    /**
     * 线程池执行任务的方法，其实就是往BlockingQueue中添加元素
     * @param task
     */
    public void execute(Runnable task) {
        try {
            taskQueue.put(task);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    /**
     * 销毁线程池
     */
    public void destroy(){
        System.out.println("ready close pool...");
        for (WorkThread workThread : workThreads) {
            workThread.stopWorker();
            workThread = null;//help gc
        }
        workThreads.clear();
    }

    /** 内部类，工作线程的实现 */
    private class WorkThread extends Thread{
        public WorkThread(String name){
            super();
            setName(name);
        }
        @Override
        public void run() {
            while (!interrupted()) {
                try {
                    Runnable runnable = taskQueue.take();//获取任务
                    if (runnable !=null) {
                        System.out.println(getName()+" ready execute:"+runnable.toString());
                        runnable.run();//执行任务
                    }
                    runnable = null;//help gc
                } catch (Exception e) {
                    interrupt();
                    e.printStackTrace();
                }
            }
        }

        public void stopWorker(){
            interrupt();
        }
    }
}

java复制代码public class TestMySelfThreadPool {

    private static final int TASK_NUM = 50;//任务的个数

    public static void main(String[] args) {
        ThreadPool myPool = new ThreadPool(3,50);
        for (int i=0;i<TASK_NUM;i++) {
            myPool.execute(new MyTask("task_"+i));
        }

    }

    static class MyTask implements Runnable{

        private String name;
        public MyTask(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }


        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("task :"+name+" end...");

        }

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return "name = "+name;
        }
    }
}