bravehans
bravehans

Spring Boot 在Netty上开发WebSocket和HTTP应用之三 -- HTTP（S）和WEBSOCKET/WSS单元测试篇

首先介绍HTTPS（含HTTP）的测试工具类，共有4个，代码如下：

public class HttpsRequestRunnable implements Runnable { 
    private static Logger logger = LoggerFactory.getLogger(HttpsRequestRunnable.class); 
    private static final LongAdder counter = new LongAdder();
    private String server_url ;
    private String strReqJson ;
    private String userId ;
    private String token ;
    public HttpsRequestRunnable(String server_url, String userId, String token,String strReqJson) {
        this.server_url = server_url ;
        this.strReqJson = strReqJson ;
        this.userId = userId ;
        this.token = token ;
    }
    public void run() {
        String respStr = HttpsRequestUtil.getFromHttps(server_url, userId, token, strReqJson);
        logger.info("respStr:{}",respStr);
        counter.increment();
        if(counter.intValue()%10==1) {
            logger.error("{} resContent {} ", counter.intValue(),respStr);
        }
    }   
}


public class HttpsRequestUtil { 
    private static Logger logger = LoggerFactory.getLogger(HttpsRequestUtil.class); 
    private static HttpURLConnection getConn(String server_url) throws Exception {
      URL url = new URL(server_url);
      if(server_url.toLowerCase().startsWith("https")) {
          HttpsURLConnection.setDefaultHostnameVerifier(new NullHostNameVerifier());
          HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
          TrustManager[] tm = { new MyX509TrustManager() };
          SSLContext sslContext = SSLContext.getInstance("TLS");
          sslContext.init(null, tm, /*new java.security.SecureRandom()*/null);
          SSLSocketFactory ssf = sslContext.getSocketFactory();          
          conn.setSSLSocketFactory(ssf);
          return conn ;
      }
      return  (HttpURLConnection) url.openConnection();
    }

    public static String getFromHttps(String server_url,String userId,String token,String strReqJson) {
        String CONTENT_TYPE = "application/json";
        StringBuilder sb2 = new StringBuilder();
        try {           
          HttpURLConnection conn = getConn(server_url);
            conn.setConnectTimeout(45 * 1000);
            conn.setReadTimeout(45 * 1000);
            conn.setDoInput(true);// 允许输入
            conn.setDoOutput(true);// 允许输出
            conn.setUseCaches(false); // 不允许使用缓存
            conn.setRequestMethod("POST");
            conn.setRequestProperty("connection", "keep-alive");
            conn.setRequestProperty("charset", "UTF-8");
            conn.setRequestProperty("Content-Type", CONTENT_TYPE);
            conn.setRequestProperty("userId", userId);
            conn.setRequestProperty("token", token);            
            DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());          
            if(StringUtil.isNotEmpty(strReqJson)) {
                outStream.write(strReqJson.getBytes());
            }
            outStream.flush();
            outStream.close();
            conn.connect();         
            InputStream in = null;
            int resCode = conn.getResponseCode();
            logger.debug("resCode {} ", resCode);
            if (resCode == 200) {
                in = conn.getInputStream();
                int ch;
                while ((ch = in.read()) != -1) {
                    sb2.append((char) ch);
                }
            }
            conn.disconnect();      
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb2.toString();
    }
}


public class MyX509TrustManager implements X509TrustManager {   
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {} 
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {} 
    public X509Certificate[] getAcceptedIssuers() {
        return null;
    }   
}

class NullHostNameVerifier implements HostnameVerifier {
    @Override
    public boolean verify(String arg0, SSLSession arg1) {
        return true;
    }
}

然后是HTTP/HTTPS单元测试类(其实完全可以将testLocalHttpLogin的内容放入一个普通类的main方法中运行)：

@SpringBootTest
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class HttpLocalFunctionTest {
  private static Logger logger = LoggerFactory.getLogger(HttpLocalFunctionTest.class);
  @Test
  public void testLocalHttpLogin() throws Exception {
    logger.info("begin2test_testLogin");
    //可以支持http和https
    String SERVER_URL = "http://127.0.0.1:8888/login" ; 
    String SERVER_URL = "https://127.0.0.1:8888/login" ; 
    String reqJson = "{\"name\":\"张三\",\"id\":0}";
    String userId = StringUtil.getRandomCode(5);
    String token  = StringUtil.getRandomCode(15);
    Thread t = new Thread(new HttpsRequestRunnable(SERVER_URL, userId,token, reqJson));
    t.start();
    t.join();
  }
}

接下来是WebSocket的模拟客户端。
需要引入 java_websocket.jar，pom.xml 如下：

    <dependency>
        <groupId>org.java-websocketgroupId>
        <artifactId>Java-WebSocketartifactId>
        <version>1.3.9version>
    dependency>

普通ws测试类对应的Java代码如下：

import java.net.URI;
import java.net.URISyntaxException;
import java.util.Map;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft;
import org.java_websocket.handshake.ServerHandshake;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 此测试类模拟 WebSocket 的客户端对服务器做压力测试
 * 注意：此类无法在创建连接的同时发送userId和token信息，导致校验无法通过。
 */
public class CommonWsClientTest extends WebSocketClient {

    private static Logger logger = LoggerFactory.getLogger(CommonWsClientTest.class);

    public CommonWsClientTest( URI serverUri , Draft draft ) {
        super( serverUri, draft );
    }

    public CommonWsClientTest( URI serverURI ) {
        super( serverURI );
    }

    public CommonWsClientTest( URI serverUri, Map httpHeaders ) {
        super(serverUri, httpHeaders);
    }

    @Override
    public void onOpen( ServerHandshake handshakedata ) {
        String msg = "{\"msgType\":0,\"msgId\":0}" ;
        logger.info("onOpen:"+msg);
        send(msg);
    }

    @Override
    public void onMessage( String message ) {
      logger.info("receiveMsg:{}",message);
    }

    @Override
    public void onClose( int code, String reason, boolean remote ) {
    }

    @Override
    public void onError( Exception ex ) {
        ex.printStackTrace();
    }

    public static void process() throws URISyntaxException {
      //请特别注意，此种方式如果连接本地，请使用127.0.0.1 而不要使用localhost 否则有时无法连接。
        String url = "ws://127.0.0.1:9999/yourappname/push" ;
        CommonWsClientTest c = new CommonWsClientTest(new URI(url)); 
        c.connect();
    }

    public static void main( String[] args ) {
        process();      
        try {
            Thread.sleep(5000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

wss模拟客户端，支持压力测试：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URI;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManagerFactory;

/**
 * 此测试类模拟 WebSecuritySocket 的客户端对服务器做压力测试
 * 注意：此类无法在创建连接的同时发送[ HTTP header] userId和token信息，导致校验无法通过。
 */
public class SSLWsClientStressTest {

  private static String url = "wss://www.yourdns.com:9999/yourappname/push";

  private static String KEYSTORE = "D:\\workspace\\netserver\\keysecurity\\hansmachine.jks";
  private static String STOREPASSWORD = "123456";
  private static String KEYPASSWORD = "123456";

  public static void main(String[] args) {
    String clientNumber = "1";
    if (args.length > 0) {
      clientNumber = args[0];
    }

    if (args.length > 1) {
      url = args[1];
    } 
    // ws and wss 的网址 不能以 / 结尾否则会报错。
    if (url.endsWith("/")) {
      url = url.substring(0, url.length() - 1);
    }
    System.out.println("-----SSLClientExample-------");
    System.out.println("clientNumber:" + clientNumber);
    System.out.println("KEYSTORE:" + KEYSTORE);
    System.out.println("url:" + url);
    for (int i = 0; i < Integer.parseInt(clientNumber); i++) {
      new Thread(new Runnable() {
        public void run() {
          try {
            process();
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }).start();
      if (i % 100 == 0) {
        try {
          Thread.sleep(20);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
    try {
      Thread.sleep(5000000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  private static  SSLContext sslContext = null ;

  public static void process() throws Exception {
    String STORETYPE = "JKS";
    WebSocketHeartBeatClient chatclient = new WebSocketHeartBeatClient(new URI(url));
    initSSLContext(STORETYPE);
    SSLSocketFactory factory = sslContext.getSocketFactory();
    chatclient.setSocket(factory.createSocket());
    chatclient.connectBlocking();
    String msg = "{\"msgType\":0,\"msgId\":0}";
    chatclient.send(msg);
    Thread.sleep(5000000);
  }

  private static void initSSLContext(String STORETYPE) throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException,
          FileNotFoundException, UnrecoverableKeyException, KeyManagementException {
    if(sslContext!=null) {
      return  ;
    }
    KeyStore ks = KeyStore.getInstance(STORETYPE);
    File kf = new File(KEYSTORE);
    ks.load(new FileInputStream(kf), STOREPASSWORD.toCharArray());

    KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
    kmf.init(ks, KEYPASSWORD.toCharArray());
    TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
    tmf.init(ks);

    SSLContext localsslContext = null;
    localsslContext = SSLContext.getInstance("TLS");
    localsslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
     sslContext = localsslContext;
  }
}
import java.net.URI;
import java.util.concurrent.atomic.LongAdder;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

public class WebSocketHeartBeatClient extends WebSocketClient {

    private static LongAdder count = new LongAdder();

    public WebSocketHeartBeatClient( URI serverUri ) {
        super( serverUri );
    }

    @Override
    public void onOpen( ServerHandshake handshakedata ) {
        //缺点：这里无法模拟发送http header信息？
        //handshakedata.
    }

    @Override
    public void onMessage( String message ) {
        //System.out.println( "got: " + message );
        count.increment();
        int c = count.intValue();
        if(c%50==0) {
            System.out.println("ReceiveMsgCount:"+c);
        }
    }

    @Override
    public void onClose( int code, String reason, boolean remote ) {
        //System.out.println( "Disconnected" );
    }

    @Override
    public void onError( Exception ex ) {
        ex.printStackTrace();
    }

}

以上两个方法都是使用的第三方客户端工具java_websocket，一般情况下够用了，但是如果考虑到安全性，
服务器端有时候会要求客户端在握手的时候发送[ HTTP header] userId和token信息进行校验，
如果校验失败服务器端拒绝连接。
此时需要Netty出马模拟客户端：

import java.net.URI;
import java.util.concurrent.atomic.LongAdder;

import javax.net.ssl.SSLException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.yjzx.server.common.util.ConfigConstants;
import com.yjzx.server.common.util.StringUtil;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;
import io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketClientCompressionHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslHandler;
import io.netty.handler.ssl.util.InsecureTrustManagerFactory;

/**
 * 目前已经实现在建立连接的时候同时发送http header 信息，
 * 然后发送一个心跳包信息。
 */
public final class WebSocketSecurityClient {
    private static Logger logger = LoggerFactory.getLogger(WebSocketSecurityClient.class);
    private static final String path = "/yourappname/push";
    private static LongAdder count = new LongAdder();
    public static void sendMessage(String json) throws Exception {
          String host = "www.yourdns.com";
          int port = 9999;
        String url = "wss://" + host + ":" + port  + path ;
        sendMessage(url,json);
    }

    /**
     * websocket 信息发送，支持 ws:// 方式和 wss:// 方式
     * 样例1：wss://www.abc.com:9999/yourdns/server
     * 样例2：ws://www.abc.com:9999/yourdns/server
     * @param url
     * @param json
     * @throws Exception
     */
    public static void sendMessage(String url, String json) throws Exception {
//      如果多一个斜线就会--没反应，也不报错！ wss://www.abc.com:9999//yourappname/server
        URI uri = new URI(url);
        String host = uri.getHost();
        int port = uri.getPort();

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();

            //握手时发送头信息，供服务器校验
            DefaultHttpHeaders customHeaders = new DefaultHttpHeaders();
            String userId = "9999" ;
            customHeaders.add("userId", userId);
            customHeaders.add("token", "ABCD9876");
            final WebSocketClientHandler webSocketClientHandler =
                    new WebSocketClientHandler(
                            WebSocketClientHandshakerFactory.newHandshaker(
                                    uri, WebSocketVersion.V13, null, true, customHeaders));

            b.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    ChannelPipeline p = ch.pipeline();

                    if(url.toLowerCase().startsWith("wss")) {
                      p.addLast("ssl", getSslHandler(ch,host,port));
                      logger.info("initChannel_AddSSLHandlerFinished");
                    }

                    p.addLast(new HttpClientCodec());
                    p.addLast(new HttpObjectAggregator(8192));
                    p.addLast(WebSocketClientCompressionHandler.INSTANCE);
                    p.addLast(webSocketClientHandler);

                }
            });

            Channel clientSocketChannel = b.connect(uri.getHost(), port).sync().channel();
            webSocketClientHandler.handshakeFuture().sync();

            count.increment();
            int c = count.intValue();
            if(c%20==0) {
                logger.warn("count:{}",c);
            }

            //服务器端与手机（设备端）约定是5分钟（300s）通过websocket发送一次心跳包
            //故此处模拟此场景。
            for (int i = 1; i <= 5; i++) {
              WebSocketFrame frame2 = new TextWebSocketFrame(json);
              clientSocketChannel.writeAndFlush(frame2);
              logger.info("begin2sleep 300s");
              Thread.sleep(300*1000);
            }

            // 不要退出
            Thread.sleep(5000000);
        } finally {
            group.shutdownGracefully();
        }
    }

    private static SslHandler getSslHandler(SocketChannel ch, String host,int port) {
        SslContext sslCtx;
        try {
            sslCtx = SslContextBuilder.forClient()
            .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
            return sslCtx.newHandler(ch.alloc(), host, port);
        } catch (SSLException e) {
            e.printStackTrace();
            return null ;
        }
    }

}

import java.util.concurrent.atomic.AtomicInteger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketHandshakeException;
import io.netty.util.CharsetUtil;

public class WebSocketClientHandler extends SimpleChannelInboundHandler {

    private static Logger logger = LoggerFactory.getLogger(WebSocketClientHandler.class);

    private final WebSocketClientHandshaker handshaker;
    private ChannelPromise handshakeFuture;

    private static AtomicInteger connSuccCounter = new AtomicInteger(0)  ;
    private static AtomicInteger connFailCounter = new AtomicInteger(0)  ;

    public WebSocketClientHandler(WebSocketClientHandshaker handshaker) {
        this.handshaker = handshaker;
    }

    public ChannelFuture handshakeFuture() {
        return handshakeFuture;
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        handshakeFuture = ctx.newPromise();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        handshaker.handshake(ctx.channel());
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        logger.info("WebSocket Client disconnected!");
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel ch = ctx.channel();
        if (!handshaker.isHandshakeComplete()) {
            try {
                handshaker.finishHandshake(ch, (FullHttpResponse) msg);
                handshakeFuture.setSuccess();

                int c = connSuccCounter.incrementAndGet();
                logger.info("CONNECTSUCC,INDEX:"+c);
            } catch (WebSocketHandshakeException e) {
                int c = connFailCounter.incrementAndGet();
                logger.info("CONNECTFAIL,INDEX:"+c);
//                logger.info("WebSocket Client failed to connect");
                handshakeFuture.setFailure(e);
            }
            return;
        }

        if (msg instanceof FullHttpResponse) {
            FullHttpResponse response = (FullHttpResponse) msg;
            throw new IllegalStateException(
                    "Unexpected FullHttpResponse (getStatus=" + response.status() +
                            ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
        }

        WebSocketFrame frame = (WebSocketFrame) msg;
        if (frame instanceof TextWebSocketFrame) {
            TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
            logger.info("WebSocket Client received message: " + textFrame.text());
        } else if (frame instanceof PongWebSocketFrame) {
            logger.info("WebSocket Client received pong");
        } else if (frame instanceof CloseWebSocketFrame) {
            logger.info("WebSocket Client received closing");
            ch.close();
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        if (!handshakeFuture.isDone()) {
            handshakeFuture.setFailure(cause);
        }
        ctx.close();
    }
}


下面这个才是测试类，当然也可以将测试方法的内容放在普通类的main方法中执行，效果是一样的


package com.yjzx.client.websocket.netty;


import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 因为本地netty作为客户端启动的时候也开了好几个线程，导致使用netty作为wss客户端的时候无法开更多线程连接服务器
 * 但是此方式可以作为功能测试。
 */
@SpringBootTest
@FixMethodOrder(MethodSorters.NAME_ASCENDING )
public class WssIntercomFunctionTest {

    private static Logger logger = LoggerFactory.getLogger(WssIntercomFunctionTest.class);

    @Test
    public void test200SendHeartBeatInWssOrWs() throws Exception {
        Thread.sleep(3000);
        String msg = "{\"msgType\":0,\"msgId\":0}" ;
        logger.info("msg:{}",msg);

        //支持 SSL 加密websocket       
        String url = "wss://www.yourdns.com:9999/yourappname/push" ;

        //也可以支持websocket方式
        String url = "ws://www.yourdns.com:9999/yourappname/push" ;

        WebSocketSecurityClient.sendMessage(url,msg);
    }

}


























你可能感兴趣的:(Spring,Boot,Netty,WebSocket)






    

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
文章永久免费只为良心
oracle数据库

    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    

    • 

  • spring如何整合druid连接池？
惜.己
springspringjunit数据库javaidea后端xml

    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    

    • 

  • SpringCloudAlibaba—Sentinel(限流)
菜鸟爪哇

    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    

    • 

  • springboot+vue项目实战一-创建SpringBoot简单项目
苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言

    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    

    • 

  • Spring MVC 全面指南：从入门到精通的详细解析
一杯梅子酱
技术栈学习springmvcjava

    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    

    • 

  • Spring Boot中实现跨域请求
BABA8891
springboot后端java

    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    

    • 

  • 博客网站制作教程
2401_85194651
javamaven

    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    

    • 

  • RabbitMQ生产者重复机制与确认机制
java炒饭小能手
java-rabbitmqrabbitmqjava

    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    

    • 

  • VUE3 + xterm + nestjs实现web远程终端 或 连接开启SSH登录的路由器和交换机。
焚木灵
node.jsvue

    可远程连接系统终端或开启SSH登录的路由器和交换机。相关资料：xtermjs/xterm.js:Aterminalfortheweb(github.com)后端实现(NestJS)：1、安装依赖：npminstallnode-ssh@nestjs/websockets@nestjs/platform-socket.io2、我们将创建一个名为RemoteControlModule的NestJS模块，
    

    • 

  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
屿小夏
java开发语言

    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    

    • 

  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
瑞金彭于晏
springboot后端javaMVCspring数据库

    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    

    • 

  • spring mvc @RequestBody String类型参数
zoyation
spring-mvcspringmvc

    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    

    • 

  • Java -jar 如何在后台运行项目
vincent_hahaha

    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    

    • 

  • spring security中几大组件的作用和执行顺序
阿信在这里
javaspring

    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    

    • 

  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
叶准鑫Natalie

    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    

    • 

  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
网顺技术团队
成品程序项目javavue.js汽车课程设计springboot

    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    

    • 

  • 分布式锁和spring事务管理
暴躁的鱼
锁及事务分布式springjava

    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    

    • 

  • 如何重启Linux服务器？
老男孩IT教育
gitlinux运维

    在Linux操作系统中，提供了多种方法用于重启服务器，那么Linux服务器如何重启?以下列举了常用的几种方法，希望对大家有所帮助，快来看看吧。重启Linux服务器有以下几种方法：1、使用命令行使用reboot命令reboot使用shutdown命令shutdown-rnow2、使用systemctl使用以下命令：systemctlreboot3、使用web界面大多数现代Linux发行版本都提供一个
    

    • 

  • Java面试笔记记录6
今天背八股了吗
java面试笔记

    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    

    • 

  • 小米嵌入式面试题目RTOS面试题目 嵌入式面试题目
好家伙VCC
面试杂谈杂谈面试职场和发展

    第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
    

    • 

  • Sentinel
眼泪落在琴弦
springcloudjavajava

    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    

    • 

  • Spring @Async 深度解读：默认线程池执行器的配置与优化
小码快撩
springjava前端

    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    

    • 

  • Sentinel实时监控不展示问题
朱杰jjj
sentinelsentinel

    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    

    • 

  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
这孩子叫逆
Mybatis笔记mybatis数据库

    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    

    • 

  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java

    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    

    • 

  • Spring Security静态资源过滤（11）
小黑屋说YYDS
spring

    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    

    • 

  • Spring Security定义多个过滤器链（10）
小黑屋说YYDS
spring

    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    

    • 

  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
"小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为

    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    

    • 

  • java 技术 架构 相关文档
圣心
java架构开发语言

    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    

    • 

  • SpringSecurity初学总结
weixin_66442229
spring

    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    

    • 

  • 集合框架
天子之骄
java数据结构集合框架

       集合框架
集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。
从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。
 
简单介绍：
 
Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
    

    • 

  • Table Driven（表驱动）方法实例
bijian1013
javaenumTable Driven表驱动

    实例一：
/**
* 驾驶人年龄段
* 保险行业，会对驾驶人的年龄做年龄段的区分判断
* 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞)
*/
public class AgePeriodTest {
//if...el
    

    • 

  • Jquery 总结
cuishikuan
javajqueryAjaxWebjquery方法

    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
    

    • 

  • 面向对象概念的提出
麦田的设计者
java面向对象面向过程

      
     面向对象中，一切都是由对象展开的，组织代码，封装数据。
  在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。
 
    下面就结合编程语言的发展史，聊一聊面向过程和面向对象。
     c语言由贝尔实
    

    • 

  • linux网口绑定
被触发
linux

    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。
一、环境描述
我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。
二、双网卡绑定步骤：
2.1 修改/etc/sysconfig/network
    

    • 

  • XML基础语法
肆无忌惮_
xml

    一、什么是XML？
XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。
 
二、为什么学习XML？
用来解决程序间数据传输的格式问题
做配置文件
充当小型数据库
 
三、XML与HTM
    

    • 

  • 为网页添加自己喜欢的字体
知了ing
字体 秒表 css

    @font-face {
font-family: miaobiao;//定义字体名字
font-style: normal;
font-weight: 400;
src: url('font/DS-DIGI-e.eot');//字体文件
}
使用：
<label style="font-size:18px;font-famil
    

    • 

  • redis范围查询应用-查找IP所在城市
矮蛋蛋
redis

    原文地址：
http://www.tuicool.com/articles/BrURbqV
需求
根据IP找到对应的城市
原来的解决方案
oracle表（ip_country）：
查询IP对应的城市：
1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994
2. select city from ip_
    

    • 

  • 输入两个整数， 计算百分比
alleni123
java

     public static String getPercent(int x, int total){
double result=(x*1.0)/(total*1.0);
System.out.println(result);
DecimalFormat df1=new DecimalFormat("0.0000%");

    

    • 

  • 百合——————>怎么学习计算机语言
百合不是茶
java 移动开发

        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
    

    • 

  • linux下tomcat开机自启动
bijian1013
tomcat

    方法一：
修改Tomcat/bin/startup.sh 为:
export JAVA_HOME=/home/java1.6.0_27
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:.
export PATH=$JAVA_HOME/bin:$PATH
export CATALINA_H
    

    • 

  • spring aop实例
bijian1013
javaspringAOP

    1.AdviceMethods.java
package com.bijian.study.spring.aop.schema;
public class AdviceMethods {
public void preGreeting() {
System.out.println("--how are you!--");
}
}
2.beans.x
    

    • 

  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization
bit1129
serialization

    enableComplexMapKeySerialization配置项的含义
 Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。
 
GsonBuilder用于
    

    • 

  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题
bit1129
Stream

    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别：
1. At most once，数据最多只能接受一次，有可能接收不到
2. At least once, 数据至少接受一次，有可能重复接收
3. Exactly once  数据保证被处理并且只被处理一次，
 
具体的多读几遍http://spark.apache.org/docs/lates
    

    • 

  • shell脚本批量检测端口是否被占用脚本
ronin47

    #!/bin/bash
cat ports |while read line
do#nc -z -w 10 $line
nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then
echo $line:ok
else
echo $line:fail
fi
done
这里的ports 既可以是文件
    

    • 

  • java-2.设计包含min函数的栈
bylijinnan
java

    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/
import java.util.ArrayList;
import java.util.List;
public class MinStack {
//maybe we can use origin array rathe
    

    • 

  • Netty源码学习-ChannelHandler
bylijinnan
javanetty

    
一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享”
例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是
因为每一次调用decode方法时，可能数据未接收完全（incomplete），
它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的
p
    

    • 

  • java生成随机数
cngolon
java

    方法一：
/**
* 生成随机数
* @author [email protected]
* @return
*/
public synchronized static String getChargeSequenceNum(String pre){
StringBuffer sequenceNum = new StringBuffer();
Date dateTime = new D
    

    • 

  • POI读写海量数据
ctrain
海量数据

    import java.io.FileOutputStream;
import java.io.OutputStream;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming
    

    • 

  • mysql 日期格式化date_format详细使用
daizj
mysqldate_format日期格式转换日期格式化

    
日期转换函数的详细使用说明
 DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
    

    • 

  • 一个程序员分享8年的开发经验
dcj3sjt126com
程序员

     
在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。
明确入行的目的
很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
    

    • 

  • android欢迎界面淡入淡出效果
dcj3sjt126com
android

    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。
主要代码如下：
package com.myaibang.activity;
import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
    

    • 

  • linux 复习笔记之常见压缩命令
eksliang
tar解压linux系统常见压缩命令linux压缩命令tar压缩

    转载请出自出处:http://eksliang.iteye.com/blog/2109693
linux中常见压缩文件的拓展名
*.gz gzip程序压缩的文件
*.bz2 bzip程序压缩的文件
*.tar tar程序打包的数据，没有经过压缩
*.tar.gz tar程序打包后，并经过gzip程序压缩
*.tar.bz2 tar程序打包后，并经过bzip程序压缩
*.zi
    

    • 

  • Android 应用程序发送shell命令
gqdy365
android

    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！
发就发吧！
一、关于shell指令：
我们知道，shell指令是Linux里面带的
    

    • 

  • java 无损读取文本文件
hw1287789687
读取文件无损读取读取文本文件charset

    java 如何无损读取文本文件呢？
以下是有损的
@Deprecated
public static String getFullContent(File file, String charset) {
BufferedReader reader = null;
if (!file.exists()) {
System.out.println("getFull
    

    • 

  • Firebase 相关文章索引
justjavac
firebase

    Awesome Firebase
最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。
Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。
开发者只需引用一个 API 库文件就可以使用标准 RE
    

    • 

  • C++学习重点
lx.asymmetric
C++笔记

    1.c++面向对象的三个特性：封装性，继承性以及多态性。
 
2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。
 
3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。
 
4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。
&n
    

    • 

  • java bean和xml相互转换
q821424508
javabeanxmlxml和bean转换java bean和xml转换

    这几天在做微信公众号
做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题，
然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ，
还是贴出来记录一下 
 
 
顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。
 
packag
    

    • 

  • C 语言初级 位运算
1140566087
位运算c

     第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
    

    • 

  • 14点睛Spring4.1-脚本编程
wiselyman
spring4

    14.1 Scripting脚本编程
脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行;
如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦;
如果我们的应用不允许重启,这在现实的情况中也是很常见的;
在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean;
spring支持脚本
    

    •