常用配置及命令V1.0

常用配置及命令V1.0

docker 安装ElasticSearch|Kibana

# 下载elasticsearch镜像文件
docker pull elasticsearch:7.4.2
# 下载kibana镜像文件
docker pull kibana:7.4.2

#创建需要挂载的文件夹
# 里面放配置文件所需的文件夹
mkdir -p /mydata/elasticsearch/config
# 里面放es的数据所需的文件夹
mkdir -p /mydata/elasticsearch/data
# 里面放es的插件所需的文件夹
mkdir -p /mydata/elasticsearch/plugins

echo "http.host: 0.0.0.0">>/mydata/elasticsearch/config/elasticsearch.yml

# 启动容器的命令
docker run --name elasticsearch -p 9200:9200 -p 9300:9300  --privileged=true \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx128m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2

#将这个目录下的所有文件授权为777
chmod -R 777 /mydata/elasticsearch/

# 重启docker
systemctl restart docker
docker start elasticsearch

# 启动kibana
docker run --name kibana --privileged=true \
-e ELASTICSEARCH_HOSTS=http://192.168.126.20:9200 -p 5601:5601 \
-d kibana:7.4.2

# ik分词器安装 1、下载压缩包
cd /mydata/elasticsearch/plugins/
wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.2/elasticsearch-analysis-ik-7.4.2.zip
# 2、解压
unzip elasticsearch-analysis-ik-7.4.2.zip -d ik7.4.2
# 4、删除
rm -rf ./*.zip
# 5、修改权限
chmod -R 777 ik7.4.2/
#重启6、es
docker restart elasticsearch


# 进入容器内部
docker exec -it containerID /bin/bash

Oracle命令

drop user emp cascade;

docker 安装nacos

## 安装nacos使用docker 安装最新版
docker pull nacos/nacos-server

## 创建文件/opt/nacos/init.d/custom.properties并复制如下内容
management.endpoints.web.exposure.include=*

## 启动
docker run -d -p 8848:8848 -e MODE=standalone -v /opt/nacos/init.d/custom.properties:/home/nacos/init.d/custom.properties -v /opt/nacos/logs:/home/nacos/logs --restart always --name nacos nacos/nacos-server

##创建数据库 nacos再添加sql

redis中的常用命令

####################String（kv键值对）########################
# 设置kv键值对 
set hello word

# 获得kv键值对
get hello

# 删除kv键值对
del hello

#####################list(链表)#######################
# 给定值推入列表右端
rpush list-key item

# 获取列表上的所有值
lrange list-key 0 -1

# 获取列表上给定位置的单个元素
lindex list-key 1

# 从列表左端弹出一个值，并返回被弹出的值
lpop list-key

#####################set(无序表)#######################
# 将给定元素添加到集合
sadd set-key item

# 返回集合包含的所有元素
smembers set-key

# 如果给定的元素存在于集合中，那么移除这个元素
srem set-key item1

#####################(散列表)#######################
# 在散列里面关联起给定的键值对
hset hash-key sub-key1 value1

# 获取散列键的值
hget hash-key sub-key1

# 获取所有的散列键值对
hgetall hash-key

# 如果给定的键在散列表里，删除给定的键值对
hdel hash-key sub-key1

#####################(有序集合)#######################
# 将一个带有给定分值的成员添加到有序集合里面
zadd zset-key 728 member

# 根据元素在有序列表中所处的位置，从有序集合里获取多个元素
zrange zset-key 0 -1 withscores

# 获取给定分值范围内的所有元素
zrangebyscore zset-key 0 800 withscores

# 如果给定成员存在于有序集合，那么移除这个成员
zrem zset-key member1

nginx常用命令

# 使用nginx操作命令的前提，进入nginx的目录
# /usr/local/nginx/sbin

# 查看版本号
./nginx -v

# 启动nginx
./nginx

# 关闭nginx
./nginx -s stop

# 重新加载nginx
./nginx -s reload

nginx的配置文件

########### 每个指令必须有分号结束。#################
#user administrator administrators;  #配置用户或者组，默认为nobody nobody。
#worker_processes 2;  #允许生成的进程数，默认为1
#pid /nginx/pid/nginx.pid;   #指定nginx进程运行文件存放地址
error_log log/error.log debug;  #制定日志路径，级别。
#这个设置可以放入全局块，http块，server块，级别以此为：debug|info|notice|warn|error|crit|alert|emerg
events {
    accept_mutex on;   #设置网路连接序列化，防止惊群现象发生，默认为on
    multi_accept on;  #设置一个进程是否同时接受多个网络连接，默认为off
    #use epoll;      #事件驱动模型，select|poll|kqueue|epoll|resig|/dev/poll|eventport
    worker_connections  1024;    #最大连接数，默认为512
}
http {
    include       mime.types;   #文件扩展名与文件类型映射表
    default_type  application/octet-stream; #默认文件类型，默认为text/plain
    #access_log off; #取消服务日志    
    log_format myFormat '$remote_addr–$remote_user [$time_local] $request $status $body_bytes_sent $http_referer $http_user_agent $http_x_forwarded_for'; #日志自定义格式
    access_log log/access.log myFormat;  #combined为日志格式的默认值
    sendfile on;   #允许sendfile方式传输文件，默认为off，可以在http块，server块，location块。
    sendfile_max_chunk 100k;  #每个进程每次调用传输数量不能大于设定的值，默认为0，即不设上限。
    keepalive_timeout 65;  #连接超时时间，默认为75s，可以在http，server，location块。

    upstream mysvr {   
      server 127.0.0.1:7878;
      server 192.168.10.121:3333 backup;  #热备
    }
    error_page 404 https://www.baidu.com; #错误页面
    server {
        keepalive_requests 120; #单连接请求上限次数。
        listen       4545;   #监听端口
        server_name  127.0.0.1;   #监听地址       
        location  ~*^.+$ {       #请求的url过滤，正则匹配，~为区分大小写，~*为不区分大小写。
           #root path;  #根目录
           #index vv.txt;  #设置默认页
           proxy_pass  http://mysvr;  #请求转向mysvr 定义的服务器列表
           deny 127.0.0.1;  #拒绝的ip
           allow 172.18.5.54; #允许的ip           
        } 
    }
}

docker常用命令

# 启动docker
sudo systemctl start docker
# 开机自启
sudo systemctl enable docker

# 检查当前所有的镜像
sudo docker images

# 查看正在运行中的容器
docker ps

# 配置阿里云镜像加速器
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://r8aan01b.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

# 镜像下载mysql5.7
docker pull mysql:5.7

# docker 启动mysql
# -v 目录挂载
docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

# mysql重启
systemctl restart mysqld.service 
# mysql启动
systemctl start mysqld.service 
# mysql停止
systemctl stop mysqld.service

# 安装redis
docker pull redis
mkdir -p /mydata/redis/conf
touch /mydata/redis/conf/redis.conf

docker run -p 6379:6379 --name redis \
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf

# redis进入控制台
docker exec -it redis redis-cli

git命令

git config --global user.name "amongdec"
git config --global user.mail "xidongdongvv@sina.com"
ssh-keygen -t rsa -C "xidongdongvv@sina.com"
cat ~/.ssh/id_rsa.pub

服务远程调用open-feign

1、引入openfeign

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2、编写一个接口来调用远程服务

/**
 * 远程调用优惠券服务的接口
 */
@FeignClient("valkyrie-coupon")
public interface CouponFeignService {

    @RequestMapping("/valkyriecoupon/coupon/feign")
    public R memberCoupon();
}

3、开启feign的远程调用功能

@EnableFeignClients(basePackages = "com.xiao.valkyriemember.feign")

Nacos作为配置中心

1、引入依赖

<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

2、编写bootstrap.properties

## 应用名称
spring.application.name=valktrie-coupon
## 连接的nacos服务器的地址
spring.cloud.nacos.config.server-addr=127.0.0.1:8848

3、在配置中心添加一个配置，名为当前应用名+.properties

4、动态获取配置

@RefreshScope//动态获取并刷新配置
@Value("${配置名}")

注意（配置中心和当前配置文件都配置相同的项，那么优先使用配置中心的配置）

常用网站

https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS 跨域问题详解网站

轮子代码，netty搭建服务器，自定义高性能

package com.montnets.mwgate.server;

import com.montnets.mwgate.common.GlobalParams;
import com.montnets.mwgate.smsutil.ConfigManager;
import com.montnets.mwgate.smsutil.SmsSendConn;

public class ServerApplication {

    static SmsSendConn smsSendConn = null;


    public static void main(String[] args) throws Exception {
        HttpServer server = new HttpServer(8888);// 8088为启动端口
        //启动服务器之前，配置全局参数
        setGlobal();

        server.start();
    }

    /**
     * 设置全局参数
     */
    public static void setGlobal() {
        // 创建全局参数
        GlobalParams globalParams = new GlobalParams();
        // 设置请求路径
        globalParams.setRequestPath("/sms/v2/std/");
        // 设置是否需要日志 1:需要日志;0:不需要日志
        globalParams.setNeedLog(1);
        // 设置响应超时时间(30即为30秒)
        globalParams.setResponseTimeout(30);
        // 设置http连接池数
        globalParams.setPoolNumber(5);
        // 设置全局参数
        ConfigManager.setGlobalParams(globalParams);
        // 是否保持长连接
        boolean isKeepAlive = true;
        // 实例化短信处理对象
        smsSendConn = new SmsSendConn(isKeepAlive);

    }
}

package com.montnets.mwgate.server;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;

public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel channel) throws Exception {
        ChannelPipeline pipeline = channel.pipeline();
        pipeline.addLast(new HttpServerCodec());// http 编解码
        pipeline.addLast("httpAggregator", new HttpObjectAggregator(512 * 1024)); // http 消息聚合器                                                                     512*1024为接收的最大contentlength
        pipeline.addLast(new HttpRequestHandler());// 请求处理器
    }
}

public class HttpServer {
    int port;

    public HttpServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        ServerBootstrap bootstrap = new ServerBootstrap();
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup work = new NioEventLoopGroup();
        bootstrap.group(boss, work)
                .handler(new LoggingHandler(LogLevel.DEBUG))
                .channel(NioServerSocketChannel.class)
                .childHandler(new HttpServerInitializer());

        ChannelFuture f = bootstrap.bind(new InetSocketAddress(port)).sync();
        System.out.println(" server start up on port : " + port);
        f.channel().closeFuture().sync();

    }

}

package com.montnets.mwgate.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFutureListener;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;

import static io.netty.handler.codec.http.HttpUtil.is100ContinueExpected;

/**
 * 用于处理netty服务器的http请求
 */
public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
        //100 Continue
        if (is100ContinueExpected(req)) {
            ctx.write(new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1,
                    HttpResponseStatus.CONTINUE));
        }
        // 获取请求的uri
        String reqUri = req.uri();

        //获取请求的方式
        HttpMethod reqMethod = req.method();

        //获取请求的参数
        String reqMsg = getRequestParam(req);

        //设置返回的参数
        String reponseMsg = "";

        //========================主要逻辑处理部分==================================
        if( HttpMethod.POST == reqMethod){
            //是Post方式
            if(reqUri == null || reqUri.length() == 0){
                //请求uri为空 ，返回信息
                reponseMsg = Result.wrap(Result.STATE_ERROR , "请求的uri为空，请重试");

            }else{
                //根据uri,执行指定方法
                reponseMsg = distributeByUri(reqUri , reqMsg);
            }

        }else{
            //不是Post方式
            reponseMsg = Result.wrap(Result.STATE_ERROR , "请求方式错误，请用POST请求");
        }
        //========================================================================


        // 创建http响应
        FullHttpResponse response = new DefaultFullHttpResponse(
                HttpVersion.HTTP_1_1,
                HttpResponseStatus.OK,
                Unpooled.copiedBuffer(reponseMsg, CharsetUtil.UTF_8));
        // 设置头信息
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=UTF-8");
        //response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
        // 将html write到客户端
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    /**
     * 获得Http请求传递过来的参数 json格式的
     * @param req 一个完整的Http请求
     * @return 返回转换出来的json字符串
     */
    private String getRequestParam(FullHttpRequest req){
        ByteBuf byteBuf = req.content();
        int length = byteBuf.readableBytes();
        byte[] array = new byte[length];
        byteBuf.getBytes(byteBuf.readerIndex(), array);
        return new String(array);
    }

    /**
     * 根据uri 和请求的参数，确定执行的业务方法
     * @return 返回执行结果，用字符串表示
     */
    private String distributeByUri(String uri , String reqmsg){

        String reponseMsg = "";

        if("/setAccountInfo".equals(uri)){
            //请求的是设置用户账号信息功能
            reponseMsg = SmsBiz.setAccountInfo(reqmsg);

        }else if("/removeAccount".equals(uri)){
            //请求移除账号功能
            reponseMsg = SmsBiz.removeAccount(reqmsg);

        }else if("/singleSend".equals(uri)){
            //请求单发接口
            reponseMsg = SmsBiz.singleSend(ServerApplication.smsSendConn , reqmsg);

        }else if("/batchSend".equals(uri)){
            //请求群发接口
            reponseMsg = SmsBiz.batchSend(ServerApplication.smsSendConn , reqmsg);

        }else if("/multiSend".equals(uri)){
            //请求自定义发送接口
            reponseMsg = SmsBiz.multiSend(ServerApplication.smsSendConn , reqmsg);

        }else if("/getRemains".equals(uri)){
            //请求查询剩余金额或条数接口
            reponseMsg = SmsBiz.getRemains(ServerApplication.smsSendConn , reqmsg);
        }else if("/getBalance".equals(uri)){
            //没有该请求
            reponseMsg = SmsBiz.getBalance(ServerApplication.smsSendConn , reqmsg);
        }

        return reponseMsg;
    }
}

Controller异常的统一处理

@Slf4j
//异常最终会从Controller抛出，我们就拦截Controller抛出的异常进行统一处理
@RestControllerAdvice(basePackages = "com.xiao.valkyrieproduct.controller")
public class AllExceptionHandler {

    //异常类型拦截
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    public R handlerException(MethodArgumentNotValidException e){
        log.error("数据校验出现问题{},异常类型{}",e.getMessage(),e.getClass());
        final BindingResult bindingResult = e.getBindingResult();

        Map<String , String> error = new HashMap<String , String>();
        bindingResult.getFieldErrors().forEach((fieldError)->{
            error.put(fieldError.getField() , fieldError.getDefaultMessage());
        });
        return R.error(400,"数据校验出现问题").put("errordata" , error);
    }

    //其他异常
    @ExceptionHandler(value = Exception.class)
    public R handler(Exception e){
        return R.error();
    }
}

SpringCloud gateway 断言配置文件

spring:
  cloud:
    gateway:
      routes:
      - id: third_route
        uri: lb://valkyrie-third-party
        predicates:
          - Path=/api/third/**
        filters:
          - RewritePath=/api/third/(?<segment>.*),/$\{segment}

      - id: product_route
        uri: lb://valkyrie-product
        predicates:
          - Path=/api/valkyrieproduct/**
        filters:
          - RewritePath=/api/(?<segment>.*),/$\{segment}

      - id: member_route
        uri: lb://valkyrie-member
        predicates:
          - Path=/api/member/**
        filters:
          - RewritePath=/api/(?<segment>.*),/$\{segment}

      - id: admin_route
        uri: lb://renren-fast
        predicates:
          - Path=/api/**
        filters:
          - RewritePath=/api/(?<segment>.*),/renren-fast/$\{segment}

配置文件大全

父模块

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xiao</groupId>
    <artifactId>valkyrie</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>valkyrie</name>
    <description>瓦尔基里聚合</description>
    <packaging>pom</packaging>

    <modules>
        <module>valkyire-order</module>
        <module>valkyrie-coupon</module>
        <module>valkyrie-member</module>
        <module>valkyrie-ware</module>
        <module>valkyrie-product</module>
        <module>renren-fast</module>
        <module>renren-generator</module>
        <module>valkyrie-common</module>
    </modules>

</project>

common模块

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>valkyrie</artifactId>
        <groupId>com.xiao</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>valkyrie-common</artifactId>

    <dependencies>
        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.12</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>

        <!-- nacos作为注册中心的依赖 --> 
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
		
        <!-- nacos作为配置中心的依赖 -->  
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <!-- jsr303校验框架 --> 
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.7.Final</version>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>


</project>

实际应用模块

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xiao</groupId>
    <artifactId>valkyrie-product</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>valkyrie-product</name>
    <description>瓦尔基里商品模块</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR5</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <artifactId>valkyrie-common</artifactId>
            <groupId>com.xiao</groupId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>