CentOS7分佈式環境搭建

歡迎使用Markdown編輯器

你好！這是你第一次使用 Markdown編輯器 所展示的歡迎頁。如果你想學習如何使用Markdown編輯器, 可以仔細閱讀這篇文章，瞭解一下Markdown的基本語法知識。

一、Kafka安裝

1、下載kafka

下載地址：http://kafka.apache.org/downloads

2、安裝kafka

將kafka上傳到 Linux裏面並解壓,kafka需要JDK的環境。

解壓kafka
tar -zxvf kafka_2.12-2.2.0.tgz
 
重命名
mv kafka_2.12-2.2.0 kafka

配置config下面的server.properties文件

broker.id=1    改爲1
 
增加ip映射，如果不增加就是locahost。這樣沒辦法使用java連接
host.name=192.168.100.129

3、kafka基本操作命令

啓動zk
bin/zookeeper-server-start.sh  config/zookeeper.properties
 
啓動kafka
bin/kafka-server-start.sh config/server.properties
 
創建tocic
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
 
查詢topic列表
bin/kafka-topics.sh --list --zookeeper localhost:2181
 
啓動 Producer
bin/kafka-console-producer.sh --broker-list 192.168.100.129:9092 --topic test
 
啓動 Consumer
bin/kafka-console-consumer.sh --bootstrap-server 192.168.100.129:9092 --topic test --from-beginning
 
topic的信息
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic test

4、使用java API 操作kafka推送和消費消息

導入kafka包

<dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka_2.12</artifactId>
</dependency>

生產者Producer代碼簡單示例

import java.util.Properties;
 
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
 
public class Producer {
    private static KafkaProducer<String, String> producer;
     
    static {
        Properties props = new Properties();
        //聲生產者kafkka地址
        props.put("bootstrap.servers", "192.168.100.129:9092");
        //key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        producer = new KafkaProducer<>(props);
    }
 
    //發送消息
    private static void send() {
        //topic   key   推送的消息
        ProducerRecord<String, String> record = new ProducerRecord<String, String>("test","key", "1231231231");
        producer.send(record);
        producer.close();
    }
 
    public static void main(String[] args) {
        send();
 
    }
}

消費者Consumer示例代碼

import java.util.Collections;
import java.util.Properties;
 
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
 
 
public class Consumer {
 
    private static KafkaConsumer<String, String> consumer;
    private static Properties props;
    static {
        props = new Properties();
        //聲生產者kafkka地址
        props.put("bootstrap.servers", "192.168.100.129:9092");
        //key反序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        //組???????
        props.put("group.id", "yangk");
    }
 
    private static void ConsumerMessage() {
        //允許自動提交位移
        props.put("enable.auto.commit", true);
        consumer = new KafkaConsumer<String, String>(props);
        consumer.subscribe(Collections.singleton("test"));
 
        //使用輪詢拉取數據--消費完成之後會根據設置時長來清除消息，被消費過的消息，如果想再次被消費，可以根據偏移量(offset)來獲取
        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(100);
                for (ConsumerRecord<String, String> r : records) {
                    System.out.printf("topic = %s, offset = %s, key = %s, value = %s", r.topic(), r.offset(),
                            r.key(), r.value());
 
                }
            }
        } finally {
            consumer.close();
        }
    }
 
    public static void main(String[] args) {
        ConsumerMessage();
    }
 
}

5、總結

在啓動kafka的時候遇到一個問題，這個問題的原因是因爲Linux中的JDK版本低的原因導致。出現錯誤還是要細心的去看錯誤日誌才能更準確的定位到錯誤的原因

這裏也算是kafka的一個簡單入門吧。後面還是需要繼續學習kafka,來解決不懂得疑問

二、MongoDB 安裝

1、安裝包下載

MongoDB下載地址： wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.0.tgz

2、MongoDB安裝

# 1.在usr/local/下創建mongodb文件夾
cd /usr/local/
mkdir mongodb

# 2.解壓文件
tar -xzvf mongodb-linux-x86_64-rhel70-4.0.1.tgz

# 3.將解壓後的文件下所有內容移動到mongodb文件夾下
# 注意這裏不是將mongodb-linux-x86_64-rhel70-4.0.1文件夾移動到創建好的mongodb下，而是文件下的內容
mv mongodb-linux-x86_64-rhel70-4.0.1/*  /usr/local/mongodb/

# 4.添加mongodb的環境變量
vi /etc/profile

# 5.在文件末尾插入如下內容
export MONGODB_HOME=/usr/local/mongodb  
export PATH=$PATH:$MONGODB_HOME/bin

# 6.修改保存後要重啓系統配置，執行命令如下
source /etc/profile

經過上述步驟，基本的配置已經完成了，接下來創建mongodb數據文件和日誌文件的存放位置，並且對啓動項進行配置，啓動項配置其中包含數據庫文件路徑和日誌文件路徑，填寫上述將要創建的文件夾或文件路徑。具體步驟如下：

# 1.創建數據庫文件存放路徑
cd /usr/local/mongodb
mkdir -p data/db
chmod -r 777 data/db

# 2.創建日誌文件
cd /usr/local/mongodb
mkdir logs
cd logs
touch mongodb.log

# 3.創建啓動文件
cd /usr/local/mongodb/bin
touch mongodb.conf

# 4.編輯啓動文件
vi mongodb.conf

# 5.在文件中插入如下內容
dbpath=/opt/mongodb/data/db  #數據文件存放目錄
logpath=/opt/mongodb/logs/mongodb.log #日誌存放目錄
port=27017 #端口
fork=true #以守護程序的方式啓用，即在後臺運行
logappend=true
maxConns=5000
storageEngine = mmapv1
bind_ip=0.0.0.0

3、啓動數據庫

# 切換到bin目錄下
cd /usr/local/mongodb/bin

# 啓動數據庫
./mongod --config mongodb.conf

# 訪問數據庫
./mongo

三、Redis 安裝

1、什麼是Redis

redis是用C語言開發的一個開源的高性能鍵值對（key-value）數據庫。它通過提供多種鍵值數據類型來適應不同場景下的存儲需求，目前爲止redis支持的鍵值數據類型如下字符串、列表（lists）、集合（sets）、有序集合（sorts sets）、哈希表（hashs）

2、Redis應用場景

緩存（數據查詢、短連接、新聞內容、商品內容等等）。（最多使用）
分佈式集羣架構中的session分離。
聊天室的在線好友列表。
任務隊列。（秒殺、搶購、12306等等）
應用排行榜。
網站訪問統計。
數據過期處理（可以精確到毫秒）

3、 Redis安裝

在CentOS環境下，Redis的安裝與部署，redis從3.0版本以後增加了集羣功能。
由於Redis是用C語言編寫，所以編譯時需要gcc，

yum install gcc-c++

通過官網下載地址：http://download.redis.io/releases/redis-5.0.0.tar.gz
或使用linux wget命令：wget http://download.redis.io/releases/redis-5.0.0.tar.gz

tar -zxvf redis-5.0.0.tar.gz

進入解壓後的目錄進行編譯make，指定目錄安裝make install 如 /usr/local/redis

cd redis-5.0.0/
make (這裏進redis-5.0.0/目錄下直接make編譯就好了)
make install PREFIX=/usr/local/redis   （指定編譯路徑）

進入安裝目錄bin下

cd /usr/local/redis/bin

目錄結構是這樣的

redis-benchmark redis性能測試工具
redis-check-aof AOF文件修復工具
redis-check-rdb RDB文件修復工具
redis-cli redis命令行客戶端
redis.conf redis配置文件
redis-sentinal redis集羣管理工具
redis-server redis服務進程

4、啓動Redis

前端模式啓動

/usr/local/redis/bin/redis-server
或 cd /usr/local/redis/bin 運行 ./redis-server

前端模式啓動的缺點是ssh命令窗口關閉則redis-server程序結束，故不推薦使用此方法。

2. 後端模式啓動
1）從redis的源碼目錄中複製redis.conf到redis的安裝目錄bin下。

cp /root/redis-5.0.0/redis.conf /usr/local/redis/bin

2）修改配置文件（是否後臺啓動）

vim /usr/local/redis/bin/redis.conf

找到 daemonize 按i 進入編輯模式把no 改爲 yes
按ESC + :wq 保存退出

執行如下命令啓動redis：

cd /usr/local/redis/bin

./redis-server ./redis.conf

查看是否啓動成功

ps aux|grep redis

redis默認端口爲 6379，可更改redis.conf文件，修改端口號

5、關閉Redis

強行終止redis進程可能會導致redis持久化數據丟失。
正確停止Redis的方式應該是向Redis發送SHUTDOWN命令，
命令爲：

cd /usr/local/redis
./bin/redis-cli shutdown

強行終止redis：pkill redis-server

6、Redis開機自啓

方法一：

vim /etc/init.d/redis 編寫腳本 (輸入下面的代碼)

# chkconfig: 2345 10 90
# description: Start and Stop redis

PATH=/usr/local/bin:/sbin:/usr/bin:/bin

REDISPORT=6379 #實際環境而定
EXEC=/usr/local/redis/bin/redis-server #實際環境而定
REDIS_CLI=/usr/local/redis/bin/redis-cli #實際環境而定

PIDFILE=/var/run/redis.pid
CONF="/usr/local/redis/bin/redis.conf" #實際環境而定

case "$1" in
        start)
                if [ -f $PIDFILE ]
                then
                        echo "$PIDFILE exists, process is already running or crashed."
                else
                        echo "Starting Redis server..."
                        $EXEC $CONF
                fi
                if [ "$?"="0" ]
                then
                        echo "Redis is running..."
                fi
                ;;
        stop)
                if [ ! -f $PIDFILE ]
                then
                        echo "$PIDFILE exists, process is not running."
                else
                        PID=$(cat $PIDFILE)
                        echo "Stopping..."
                        $REDIS_CLI -p $REDISPORT SHUTDOWN
                        while [ -x $PIDFILE ]
                        do
                                echo "Waiting for Redis to shutdown..."
                                sleep 1
                        done
                        echo "Redis stopped"
                fi
                ;;
        restart|force-reload)
                ${0} stop
                ${0} start
                ;;
        *)
                echo "Usage: /etc/init.d/redis {start|stop|restart|force-reload}" >&2
                exit 1
esac

配置開機啓動

chmod 755 /etc/init.d/redis #設置文件redis的權限，讓Linux可以執行
chkconfig redis on    #開啓服務自啓動
chkconfig --list      #查看所有註冊的腳本文件
service redis start   #啓動
service redis stop    #關閉redis

3）檢測是否成功

reboot  #重啓--如果是centos6.5學過來的，init 0與init 6一樣在centos7適用
ps aux|grep redis #查看redis進程是否存在

方法二：(centos7推薦)
centos 7以上是用Systemd進行系統初始化的，Systemd 是 Linux 系統中最新的初始化系統（init），它主要的設計目標是克服 sysvinit 固有的缺點，提高系統的啓動速度。
Systemd服務文件以.service結尾，比如現在要建立redis爲開機啓動，如果用yum install命令安裝的，yum命令會自動創建redis.service文件，直接用命令systemcel enable redis.service設置開機啓動即可

在系統服務目錄裏創建redis.service文件

vim /etc/systemd/system/redis.service

寫入以下內容：

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/redis/bin/redis-server /usr/local/redis/bin/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

注意：ExecStart配置成自己的路徑
配置描述：
　　Description:描述服務
　　After:描述服務類別
　　[Service]服務運行參數的設置
　　Type=forking是後臺運行的形式
　　ExecStart爲服務的具體運行命令
　　ExecReload爲重啓命令
　　ExecStop爲停止命令
　　PrivateTmp=True表示給服務分配獨立的臨時空間
　　注意：[Service]的啓動、重啓、停止命令全部要求使用絕對路徑
　　[Install]運行級別下服務安裝的相關設置，可設置爲多用戶，即系統運行級別爲3

重載系統服務：systemctl daemon-reload

測試並加入開機自啓
先關閉redis-server
　systemctl stop redis.service
　開啓redis-server
　systemctl start redis.service #如果服務是開啓狀態，使用此命令會啓動失敗。
開啓成功，將服務加入開機自啓
　　systemctl enable redis.service #注意後面不能跟空格
reboot #重啓
查看服務運行狀態：systemctl status redis.service
全部命令
　　systemctl start redis.service #啓動redis服務
　　systemctl enable redis.service #設置開機自啓動
　　systemctl disable redis.service #停止開機自啓動
　　systemctl status redis.service #查看服務當前狀態
　　systemctl restart redis.service　 #重新啓動服務
　　systemctl list-units --type=service #查看所有已啓動的服務
測試代碼
引入jar包：

public class JedisTest {

    @Test
    public void testJedisSingle() {
        //創建一個jedis的對象。
        Jedis jedis = new Jedis("172.20.10.7", 6379);
        //調用jedis對象的方法，方法名稱和redis的命令一致。
        jedis.set("key1", "jedis test");
        String str = jedis.get("key1");
        System.out.println(str);
        //關閉jedis。
        jedis.close();
    }
    
    /**
     * 使用連接池
     */
    @Test
    public void testJedisPool() {
        //創建jedis連接池
        JedisPool pool = new JedisPool("172.20.10.7", 6379);
        //從連接池中獲得Jedis對象
        Jedis jedis = pool.getResource();
        String str = jedis.get("key1");
        System.out.println(str);
        //關閉jedis對象
        jedis.close();
        pool.close();
    }
}

至此redis安裝配置完畢。

四、安裝ElasticSearch

1、檢測是否安裝了Elasticsearch

ps aux |grep elasticsearch

2、安裝JDK

3、下載Elasticsearch

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.0.0.tar.gz
# 解壓Elasticsearch
tar -zxvf elasticsearch-6.0.0.tar.gz
# 移動Elasticsearch到/usr/local/elasticsearch
mv elasticsearch-6.0.0 /usr/local/elasticsearch

4. 修改配置文件

進入/usr/local/elasticsearch/config目錄，使用vi編輯器

 vi elasticsearch.yml
 network.host: 192.168.181.201
discovery.zen.ping.unicast.hosts: ["192.168.181.201"]

修改/etc/sysctl.conf否則會出現
max virutal memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

vm.max_map_count=262144

退出保存後執行如下命令:

sysctl -p

使用vi編輯器，修改/etc/security/limits.conf文件，在文件末尾添加如下代碼,否則會出現
max number of threads [3750] for user [xxx] is too low, increase to at least [4096]

1 # sanglp爲登錄服務器的用戶名
2 
3 sanglp soft nofile 65536
4 sanglp hard nofile 65536
5 sanglp soft nproc  4096
6 sanglp hard nproc  4096

切記退出重新登錄。

啓動Elasticsearch
進入/usr/local/elasticsearch目錄之中，輸入以下命令，開始Elasticsearch服務：

1 ./bin/elasticsearch

新建spring boot的elasticsearch項目
在start.spring.io中新建springboot項目，並導入到intellij中
pom.xml

<?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">
        <modelVersion>4.0.0</modelVersion>

        <groupId>com.slp</groupId>
        <artifactId>springboot-elasticsearch</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>

        <name>springboot-elasticsearch</name>
        <description>Demo project for Spring Boot</description>

        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.0.BUILD-SNAPSHOT</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>

        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>

        <dependencies>
            <!--添加web的應用依賴-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!--添加spring-data-elasticsearch的依賴-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            </dependency>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>

            <dependency>
                <groupId>net.java.dev.jna</groupId>
                <artifactId>jna</artifactId>
                <version>3.0.9</version>
            </dependency>
        </dependencies>

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

        <repositories>
            <repository>
                <id>spring-snapshots</id>
                <name>Spring Snapshots</name>
                <url>https://repo.spring.io/snapshot</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </repository>
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>

        <pluginRepositories>
            <pluginRepository>
                <id>spring-snapshots</id>
                <name>Spring Snapshots</name>
                <url>https://repo.spring.io/snapshot</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </pluginRepository>
            <pluginRepository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </pluginRepository>
        </pluginRepositories>
    </project>

application.yml

spring:
    data:
         elasticsearch:
             cluster-name:  elasticsearch #默認爲elasticsearch
             cluster-nodes: 192.168.181.201:9300 #配置es節點信息，逗號分隔，如果沒有指定，則啓動ClientNode
             properties:
                 path:
                   logs: ./elasticsearch/log #elasticsearch日誌存儲目錄
                   data: ./elasticsearch/data #elasticsearch數據存儲目錄

Article.java

package com.slp.springbootelasticsearch.pojo;
import org.springframework.data.elasticsearch.annotations.Document;
import java.io.Serializable;
    
/**
 * @author sanglp
 * @create 2018-07-04 9:06
 * @desc 文章實體類,默認情況下添加@Document註解會對實體中的所有屬性建立索引，
 **/
@Document(indexName = "projectname",type = "article",indexStoreType = "fs",shards = 5,replicas = 1,refreshInterval = "-1")
public class Article implements Serializable {
    
    private Long id;
    /**
     * 標題
     */
    private String title;
    /**
     * 摘要
     */
    private String abstracts;
    /**
     * 內容
     */
    private String content;
    /**
     * 發表時間
     */
    private String postTime;
    /**
     * 點擊率
     */
    private String clickCount;
    /**
     * 作者
     */
    private Author author;
    /**
     * 所屬教程
     */
    private Tutorial tutorial;
}

Author.java

package com.slp.springbootelasticsearch.pojo;
import java.io.Serializable;
/**
 * @author sanglp
 * @create 2018-07-04 9:04
 * @desc 作者實體類
 **/
public class Author  implements Serializable{
	/**
     * 作者ID
     */
    private Long id;
    /**
     * 作者姓名
     */
    private String name;
    /**
     * 作者簡介
     */
    private String remark;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
}

Tutorial.java

package com.slp.springbootelasticsearch.pojo;
import java.io.Serializable;
/**
  * @author sanglp
  * @create 2018-07-04 9:03
  * @desc 實體類
  **/
public class Tutorial implements Serializable {
	private Long id;
    //教程名稱
     private String name ;

     public Long getId() {
         return id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

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

@Document註解裏面的幾個屬性，類比mysql的話是這樣：
index –> DB
type –> Table
Document –> row
@Id註解加上後，在Elasticsearch裏相應於該列就是主鍵了，在查詢時就可以直接用主鍵查詢，後面再看。其實和mysql非常類似，基本就是一個數據庫。

@Persistent
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Document {
    
    String indexName();//索引庫的名稱，個人建議以項目的名稱命名
    
    String type() default "";//類型，個人建議以實體的名稱命名
    
     short shards() default 5;//默認分區數
    
     short replicas() default 1;//每個分區默認的備份數
    
     String refreshInterval() default "1s";//刷新間隔
    
     String indexStoreType() default "fs";//索引文件存儲類型
}

加上了@Document註解之後，默認情況下這個實體中所有的屬性都會被建立索引、並且分詞。
我們通過@Field註解來進行詳細的指定，如果沒有特殊需求，那麼只需要添加@Document即可。

@Field註解的定義如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
@Inherited
public @interface Field {

	FieldType type() default FieldType.Auto;#自動檢測屬性的類型
	
	FieldIndex index() default FieldIndex.analyzed;#默認情況下分詞
	
	DateFormat format() default DateFormat.none;
	
	String pattern() default "";
	
	boolean store() default false;#默認情況下不存儲原文
	
	String searchAnalyzer() default "";#指定字段搜索時使用的分詞器
	
	String indexAnalyzer() default "";#指定字段建立索引時指定的分詞器
	
	String[] ignoreFields() default {};#如果某個字段需要被忽略
	
	boolean includeInParent() default false;
}

ArticleSearchRepository.java相當於dao

package com.slp.springbootelasticsearch.repository;

import com.slp.springbootelasticsearch.pojo.Article;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**
 * @author sanglp
 * @create 2018-07-04 9:27
 * @desc 文章reposiroty  泛型的參數分別是實體類型和主鍵類型
 **/
public interface ArticleSearchRepository extends ElasticsearchRepository<Article,Long> {
    
}

測試用例

package com.slp.springbootelasticsearch;

import com.slp.springbootelasticsearch.pojo.Article;
import com.slp.springbootelasticsearch.pojo.Author;
import com.slp.springbootelasticsearch.pojo.Tutorial;
import com.slp.springbootelasticsearch.repository.ArticleSearchRepository;
import org.elasticsearch.index.query.QueryStringQueryBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Iterator;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootElasticsearchApplicationTests {

    @Test
    public void contextLoads() {
    }
    @Autowired
    private ArticleSearchRepository articleSearchRepository;
    @Test
    public void testSaveArticleIndex(){
        Author author = new Author();
        author.setId(1L);
        author.setName("slp");
        author.setRemark("test");

        Tutorial tutorial = new Tutorial();
        tutorial.setId(1L);
        tutorial.setName("elastic search");

        Article article = new Article();
        article.setId(1L);
        article.setTitle("spring boot integrate elasticsearch");
        article.setAbstracts("elasticsearch is very easy");
        article.setTutorial(tutorial);
        article.setAuthor(author);
        article.setContent("elasticsearch based on lucene");
        article.setPostTime("20180704");
        article.setClickCount("1");
        articleSearchRepository.save(article);

    }

    @Test
    public void testSearch(){
        String queryString="spring";//搜索關鍵字
        QueryStringQueryBuilder builder=new QueryStringQueryBuilder(queryString);
        Iterable<Article> searchResult = articleSearchRepository.search(builder);
        Iterator<Article> iterator = searchResult.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next().getAbstracts());
        }
    }
}

五、安裝MySQL5.7解壓版

1、使用wget 下載MySQL安裝包

wget https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.26-linux-glibc2.12-x86_64.tar.gz

2、安裝libaio庫

yum install libaio

3、解壓安裝包

tar -zxvf mysql-5.7.26-linux-glibc2.12-x86_64.tar.gz

4、添加用戶和用戶組

groupadd mysql
useradd -r -g mysql -s /bin/false mysql

5、初始化數據目錄

cd mysql5.7
mkdir mysql-files
 
#將目錄用戶和組所有權授予 mysql用戶和mysql 組，並相應地設置目錄權限：
chown mysql:mysql mysql-files 
chmod 750 mysql-files

6、配置my.cnf文件

刪除CentOS7 etc目錄自帶的my.cnf 和 my.cnf.d

rm -rf  /etc/my.*

配置新的my.cnf

#新建一個my.cnf
vim /etc/my.cnf

加入如下配置

[client]
port = 3306
socket = /tmp/mysql.sock
[mysqld]
init-connect='SET NAMES utf8'
socket=/tmp/mysql.sock #mysql啓動時生成的文件
basedir=/usr/local/mysql/mysql5.7/ 
datadir=/usr/local/mysql/mysql5.7/data
max_connections=200             # 允許最大連接數
character-set-server=utf8           # 服務端使用的字符集默認爲8比特編碼的latin1字符集
default-storage-engine=INNODB           # 創建新表時將使用的默認存儲引擎
[mysqld_safe]
log-error=/usr/local/mysql/mysql5.7/data/mariadb.log
pid-file=/usr/local/mysql/mysql5.7/data/mariadb.pid
# skip-grant-tables   免密碼登錄

7、配置mysql環境變量


vim /etc/profile
#在最後一行加入:
export PATH=$PATH:/usr/local/mysql/mysql5.7/bin
#重新加載配置文件使配置的環境變量生效:
source /etc/profile

8、初始化MySQL

#不生成初始密碼
mysqld --initialize-insecure --user=mysql --basedir=/usr/local/mysql/mysql5.7/ --datadir=/usr/local/mysql/mysql5.7/data

9、啓動MySQL

#卡住不動回車
mysqld_safe --user=mysql &

10、登錄

mysql -u root -p

11、修改密碼

use mysql;
 
update user set authentication_string=password('這裏填你設置的密碼') where user='root';
 
flush privileges;#刷新信息
 
exit; #退出

12、配置外網可以訪問

mysql -uroot -p
#輸入剛纔設置的密碼
use mysql;
select host,user from user;
#這個是隻有本地可以訪問

update user set host='%' where user ='root';
flush privileges;
查看一下是否配置成功
select host,user from user;

13、把MySQL爲服務並設置開機啓動

#複製啓動腳本
cp /usr/local/mysql/mysql5.7/support-files/mysql.server  /etc/init.d/mysql
#添加服務
chkconfig --add mysql
#設置開機啓動
chkconfig --level 345 mysql on
#查看服務列表
chkconfig --list

#開啓
service mysql start
#查看狀態
service mysql status
#停止mysql服務
service mysql stop

limx-csd

發佈了2 篇原創文章 · 獲贊 0 · 訪問量 168

私信關注

CentOS7分佈式環境搭建

CentOS7分佈式環境搭建

歡迎使用Markdown編輯器

一、Kafka安裝

1、下載kafka

2、安裝kafka

3、kafka基本操作命令

4、使用java API 操作kafka推送和消費消息

5、總結

二、MongoDB 安裝

1、安裝包下載

2、MongoDB安裝

3、啓動數據庫

三、Redis 安裝

1、什麼是Redis

2、Redis應用場景

3、 Redis安裝

4、啓動Redis

5、 關閉Redis

6、Redis開機自啓

四、安裝ElasticSearch

1、檢測是否安裝了Elasticsearch

2、 安裝JDK

3、下載Elasticsearch

4. 修改配置文件

五、安裝MySQL5.7解壓版

1、使用wget 下載MySQL安裝包

2、安裝libaio庫

3、解壓安裝包

4、添加用戶和用戶組

5、初始化數據目錄

6、配置my.cnf文件

7、配置mysql環境變量

8、初始化MySQL

9、啓動MySQL

10、登錄

11、修改密碼

12、配置外網可以訪問

13、把MySQL爲服務並設置開機啓動

5、關閉Redis

2、安裝JDK