Linux部署配置JDK,mysql,nginx,redis,mycat,zookeeper

1.1 Linux常用命令:

1.1.1 CD命令集

ifconfig/ip addr 检查IP地址
pwd 检查当前的位置
tab键 自动补齐(注意唯一性)
cd命令是linux中最基本的命令语句，必须熟练掌握
cd / 返回根目录
cd ~ 用户主目录
cd . 当前目录
cd …返回到上一级目录
cd /usr/ 进入到usr目录
cd – 返回上一个目录
cd 直接回家

1.1.2 ls目录和文件**

ls –l 详细格式，文件权限，时间
ll 和ls –l作用相同
ls *.txt 查看所有的txt类型文档

1.1.3 目录操作**

mkdir 创建目录
mkdir a 创建 a目录
mkdir -p a/b 创建 a目录，并在a目录里创建b目录
mkdir -m 777 c 创建一个权限为777的C目录
rmdir 删除目录（如果目录里有文件，则不能用此命令）

1.1.4 vi/vim创建/查看/编辑文件**

命令行：Esc切换到命令行模式。
编辑模式：
按i，在光标前开始编辑
按a，在光标后开始编辑
按o，在当前行的下一行开始编辑
按u, 撤销之前的操作
底行模式：按 shift+：冒号。
:q! 不保存退出
:wq 保存退出
:/world 从当前光标处，向上查找world关键字
:?world 从当前光标处，向后查找world关键字

1.1.5 删除文件**

rm 删除文件
rm n.txt 提示y删除n放弃
rm –f n.txt 不提示
rm –rf dirname 不提示递归删除目录下所以内容
rm –rf * 删除所有文件
rm –rf /* 删除所有子目录所有和文件

1.1.6 复制和移动文件**

cp复制文件
cp nginx.conf n.txt
cp –R tomcat1 tomcat2 #复制整个目录
mv 修改文件名，移动文件
mv n.txt m.txt 修改文件名称

1.1.7 浏览文件**

cat 输出文件所有的内容
more 输出文档所有的内容，分页输出，空格浏览下一屏，q退出
less 用法和more相同，只是通过PgUp、PgOn键来控制
tail 用于显示文件后几号，使用频繁
tail -10 nginx.conf 查看nginx.conf的最后10行
tail –f nginx.conf 动态查看日志，方便查看日志新增的信息
ctrl+c 结束查看

1.1.8 打包命令**

tar命令位于/bin目录下，它能够将用户所指定的文件或目录打包成一个文件，但不做压缩。一般Linux上常用的压缩方式是选用tar将许多文件打包成一个文件，再以gzip压缩命令压缩成name.tar.gz的文件。
-c 创建一个新的tar文件
-v 显示运行过程的信息
-f 指定文件名
-z 调用gzip压缩命令进行压缩
-t 查看压缩文件的内容
-x 解开tar文件
tar –cvf n.tar ./* 压缩当前目录下的所有文件和目录，文件名为n.tar
tar –xvf n.tar 解压压缩包中的文件到当前目录（如果长时间未解压成功 Ctrl+C推出）
tar –cvzf m.tar.gz ./* 压缩文件
tar -zxvf m.tar.gz 解压m.tar文件到当前目录

1.1.9 grep命令**

grep root /etc/passwd 在文件中查找关键字root
grep root /etc/passwd –-color 高亮显示
grep root /etc/passwd –A5 –B5 高亮显示，A后5行，B
grep -n root /etc/passwd 查找并显示行数
grep -v root /etc/passwd 取反，查出不含root的数据

2.1 JDK安装及配置

2.1.1上传安装包

说明:将JDK安装包上传到指定文件目录下/usr/local/src下

命令:

tar -xvf jdk-7u51-linux-x64.tar.gz

解压到当前目录即可

2.1.2配置环境变量

说明:修改Linux系统中环境变量需要修改/etc/profile文件
命令:

vim /etc/profile

配置文件变量

#set java env
JAVA_HOME=/usr/local/src/java/jdk1.7.0_51
JAVA_BIN=/usr/local/src/java/jdk1.7.0_51/bin
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export JAVA_HOME JAVA_BIN PATH CLASSPATH

配置完后,让环境变量生效命令:

source /etc/profile

2.1.3 检查jdk是否生效

命令:

java -version

如图,即配置成功!

3.1 mysql安装及配置

3.1.1 安装mariadb数据库

同上,可以使用安装包直接上传,或者使用yum命令:

yum install mariadb-server

3.1.2 配置数据库

数据库操作命令

1.启动数据库命令 systemctl start mariadb

2.停止数据库命令 systemctl stop mariadb

3.重启数据库命令 systemctl restart mariadb

配置命令:

mysql_secure_installation

3.1.3 数据库登录

3.1.4 设定数据库权限

修改用户权限列表

刷新数据库权限

命令:

flush privileges;
数据库安装成功

4.1 Linux防火墙说明

4.1.1 防火墙配置

1).配置以后不开启防火墙
命令

systemctl disable firewalld.service
** 2).配置以后开启防火墙2).配置以后开启防火墙**
命令
systemctl enable firewalld.service

3).检查防火墙工作状态

firewall-cmd --state
** 4).关闭/启动防火墙**
systemctl stop firewalld.service
systemctl start firewalld.service

4.1.2 指定端口号开放

	firewall-cmd --zone=public --add-port=3306/tcp --permanent

命令含义：
					–zone #作用域
					–add-port=80/tcp #添加端口，格式为：端口/通讯协议
					–permanent #永久生效，没有此参数重启后失效

5.1 tomcat启动程序

关闭tomcat服务器
命令

5.1.1 通过脚本同时启动多台tomcat服务器

命令

vim start.sh
编辑文件

#!/bin/sh
nohup java -jar 8081.war -> 8081.log &
nohup java -jar 8082.war -> 8082.log &
nohup java -jar 8083.war -> 8083.log &

运行程序

sh start.sh

6.1 nginx配置及安装

6.1.1 下载或上传NGINX文件

下载安装包命令:

6.1.2nginx路径说明

说明: nginx的环境配置有2个环境.
环境1: /usr/local/src/nginx 该路径是nginx的源文件路径 主要负责编译/安装等工作 (安装)
环境2: /usr/local/nginx 该路径是nginx的工作路径 主要实现反向代理配置工作 (工作)

6.1.3 安装nginx

命令:

./configure

命令1:make
命令2: make install

查看位置
命令:

6.1.4 启动nginx

命令

1.启动nginx ./nginx
2.重启nginx ./nginx -s reload
3.关闭nginx ./nginx -s stop

安装成功!

6.1.5修改nginx配置信息

修改配置文件 nginx.conf 路径:/usr/local/nginx/conf目录
#配置图片服务器

server {
	listen 80;
	server_name  image.jt.com;

	location / {
		#配置反向代理的路径
		root  /usr/local/src/images;
	}
}

#配置域名代理
server {
	listen 80;
	server_name  manage.jt.com;

	location / {
		#代理tomcat服务器
		proxy_pass  http://tomcats;
	}
}

#配置tomcat集群  默认是轮询策略
upstream tomcats {
	server localhost:8081;
	server localhost:8082;
	server localhost:8083;
}

修改完后重启服务器

7.1 主从数据库设计

7.1.1 数据库热备份原理

工作原理说明:
1.数据库主库将更新的数据信息写入到二进制日志文件中.
2.数据库从库通过IO线程去主库中获取二进制文件修改内容. 之后写入到中继日志中
3.数据库从库中的Sql线程读取中继日志中的信息,实现数据的同步.
并且为了降低组件之间的耦合性,采用异步的方式处理.

7.1.2 准备第二台Linux操作系统

修改虚拟机IP地址
规定: 主机IP地址 192.168.126.129 从机 192.168.126.130
1).进入修改IP地址目录
命令

cd /etc/sysconfig/network-scripts/

2).修改配置文件信息

3).重置网卡

7.1.3 数据库主从配置

开启数据库二进制文件
修改配置文件

vim /etc/my.cnf

修改之后,重启数据库

开启从库二进制文件

7.1.4 利用sqlYog工具链接从库

数据库中执行命令

实现主从挂载

/130是从机 实现主从的挂载 host/port/user/password/二进制文件/位置/
change MASTER to MASTER_HOST=“192.168.126.129”, MASTER_PORT=3306,
MASTER_USER=“root”, MASTER_PASSWORD=“root”,
MASTER_LOG_FILE=“mysql-bin.000001”, MASTER_LOG_POS=245;

/开启主从服务/
start slave;

/检查主从同步状态/
show SLAVE status;

主从状态说明

8.1 mycat数据库代理服务器

8.1.1读写分离说明

8.1.2 mycat安装

官网下载

tar -xvf Mycat-server-1.7.0-DEV-20170416134921-linux.tar.gz
下载解压即可

8.1.3配置文件

server.xml配置
注意事项: 数据库代理的端口号 8066端口

<!--用户标签-->
	<user name="root">
		<property name="password">root</property>
		<!--与schema.xml中的配置相同 注意数据库的大小写-->
		<property name="schemas">jtdb</property>
	</user>

	<user name="user">
		<property name="password">user</property>
		<property name="schemas">jtdb</property>
		<property name="readOnly">true</property>
	</user>

schema.xml
配置说明:该配置表示了读写分离/负载均衡的设置.

<writeHost host="hostM1" url="192.168.126.129:3306" user="root" password="root">
		<!--读数据库1-->
		<readHost host="hostS1" url="192.168.126.130:3306" user="root" password="root" />
		<!--读数据库2-->
		<readHost host="hostS2" url="192.168.126.129:3306" user="root" password="root" />
		
	</writeHost>

8.1.4 启动mycat

启动效果

修改java配置文件里的数据源配置

spring:
  datasource:
    #引入druid数据源
    #type: com.alibaba.druid.pool.DruidDataSource
    #driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.126.129:8066/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root

8.1.5 数据库双主热备

利用sqlYog主从挂载

/我之前是主库 现在是从库/
CHANGE MASTER TO MASTER_HOST=“192.168.126.130”,
MASTER_PORT=3306, MASTER_user=“root”, MASTER_PASSWORD=“root”,
MASTER_LOG_FILE=“mysql-bin.000001”, MASTER_LOG_POS=482;

/* 启动主从服务*/
start slave

show SLAVE status;

8.1.7配置数据库高可用

说明: 当其中有一台数据库宕机之后,用户依然可以正确的访问数据库不受任何影响,(实现了故障迁移).主要数据库能够正常的工作,则重新启动数据库之后则可以实现自动的数据的同步.

配置文件修改:
schema.xml

	<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
	
	<!--name属性是自定义的  dataNode表示数据库的节点信息  jtdb表示逻辑库-->
	<schema name="jtdb" checkSQLschema="false" sqlMaxLimit="100" dataNode="jtdb"/>

	<!--定义节点名称/节点主机/数据名称-->
	<dataNode name="jtdb" dataHost="localhost1" database="jtdb" />
		<!--参数介绍-->
		<!--balance 0表示所有的读操作都会发往writeHost主机 -->  
		<!--1表示所有的读操作发往readHost和闲置的主节点中-->
		<!--writeType=0 所有的写操作都发往第一个writeHost主机-->	
		<!--writeType=1 所有的写操作随机发往writeHost中-->
		<!--dbType 表示数据库类型 mysql/oracle-->
		<!--dbDriver="native"  固定参数 不变-->
		<!--switchType=-1 表示不自动切换, 主机宕机后不会自动切换从节点-->
		<!--switchType=1  表示会自动切换(默认值)如果第一个主节点宕机后,Mycat会进行3次心跳检测,如果3次都没有响应,则会自动切换到第二个主节点-->
		<!--并且会更新/conf/dnindex.properties文件的主节点信息 localhost1=0 表示第一个节点.该文件不要随意修改否则会出现大问题-->
	<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<!--心跳检测策略-->
		<heartbeat>select 1</heartbeat>

		<!--配置第一台主机主要进行写库操作,在默认的条件下Mycat主要操作第一台主机在第一台主机中已经实现了读写分离.因为默认写操作会发往137的数据库.读的操作默认发往141.如果从节点比较忙,则主节点分担部分压力.
		-->
		<writeHost host="hostM1" url="192.168.126.129:3306" user="root" password="root">
			<!--读数据库1-->
			<readHost host="hostS1" url="192.168.126.130:3306" user="root" password="root" />
			<!--读数据库2-->
			<readHost host="hostS2" url="192.168.126.129:3306" user="root" password="root" />
			
		</writeHost>

			<!--定义第二台主机 由于数据库内部已经实现了双机热备.-->
			<!--Mycat实现高可用.当第一个主机137宕机后.mycat会自动发出心跳检测.检测3次.-->
			<!--如果主机137没有给Mycat响应则判断主机死亡.则回启东第二台主机继续为用户提供服务.-->
			<!--如果137主机恢复之后则处于等待状态.如果141宕机则137再次持续为用户提供服务.-->
			<!--前提:实现双机热备.-->
		
		<writeHost host="hostM2" url="192.168.126.130:3306" user="root" password="root">-
			<!--读数据库1-->
			<readHost host="hostS1" url="192.168.126.130:3306" user="root" password="root" />
			<!--读数据库2-->
			<readHost host="hostS2" url="192.168.126.129:3306" user="root" password="root" />
		</writeHost>
		
	</dataHost>
</mycat:schema>

完成!!!

9.1 Redis缓存

9.1.1缓存机制说明

9.1.2 redis安装

上传解压文件.

说明:在redis的根目录中执行
1). make
2). make install

9.1.3 redis配置文件

编辑redis.conf

vim redis.conf

修改ip绑定

修改保护模式

开启后台启动

9.1.4 redis服务命令

1.启动redis redis-server redis.conf
2.进入客户端 redis-cli -p 6379
3.关闭redis redis-cli -p 6379 shutdown
简化操作: 如果操作的redis是默认的端口 则可以省略不写.

9.1.5 redis入门案例说明

导入jar包

<!--spring整合redis -->
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
</dependency>

编辑测试类

	package com.jt.test;

import org.junit.jupiter.api.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.params.SetParams;

public class TestRedis {
	
	/**
	 * 1.spring整合redis
	 * 报错说明:
	 * 	1).如果测试过程中报错 则检查redis配置文件  改3处
	 *  2).检查redis启动方式   redis-server redis.conf
	 *  3).检查Linux的防火墙
	 * 	做完的 测试其他命令.
	 */
	@Test
	public void testString01() {
		
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		//2.操作redis
		jedis.set("a", "redis入门案例");
		String value = jedis.get("a");
		System.out.println(value);
	}
	
	@Test
	public void testString02() {
		
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		//2.判断当前数据是否存在
		if(jedis.exists("a")) {
			System.out.println(jedis.get("a"));
		}else {
			
			jedis.set("a", "测试是否存在的方法");
		}
		
	}
	
	/**
	 * 1.能否简化是否存在的判断
	 * 2.如果该数据不存在时修改数据,否则不修改
	 * setnx方法:  只有当数据不存在时赋值.
	 */
	@Test
	public void testString03() {
	
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		jedis.flushAll(); //清空所有的redis缓存
		jedis.setnx("a", "测试setnx方法1");
		jedis.setnx("a", "测试setnx方法2");
		System.out.println(jedis.get("a"));
	}
	
	/**
	 * 为数据添加超时时间
	 * @throws InterruptedException 
	 * setex方法  保证赋值操作和添加超时时间的操作的原子性
	 * 原子性: 要么同时成功,要么同时失败(类似事务)
	 */
	@Test
	public void testString04() throws InterruptedException {
	
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		jedis.flushAll(); //清空所有的redis缓存
		
		jedis.set("a", "aaaa"); //如果程序报错,则超时方法将不会执行,改数据将永不超时
		//程序报错,意外终止!!!!!!!
		jedis.expire("a", 20);	//添加超时时间    不是原子性操作
		Thread.sleep(2000);
		System.out.println("剩余存活时间:"+jedis.ttl("a"));
		
		//2.实现原子性操作
		jedis.setex("b", 20, "原子性测试");
		System.out.println(jedis.get("b"));
		
	}
	
	
	/**
	 *
	 * 1.只有数据不存在时允许修改
	 * 2.要求实现添加超时时间,并且是原子性操作
	 * SetParams 参数说明:
	 * 	1.NX   只有key不存在时才能修改
	 * 	2.XX   只有key存在时,才能修改
	 *  3.PX   添加的时间单位是毫秒
	 *  4.EX   添加的时间单位是秒
	 */
	@Test
	public void testString05(){
	
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		jedis.flushAll(); //清空所有的redis缓存
		SetParams params = new SetParams();
		params.xx().ex(20);
		jedis.set("aa", "测试A", params);	
		jedis.set("aa", "测试B", params);	
		System.out.println(jedis.get("aa"));
	}
	
	
	
	/**
	 * 存储一类数据时,可以使用hash.
	 */
	@Test
	public void testHASH(){
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		jedis.flushAll(); //清空所有的redis缓存
		jedis.hset("user", "name", "tomcat");
		jedis.hset("user", "id", "100");
		System.out.println(jedis.hgetAll("user"));
	}
	
	
	@Test
	public void testList(){
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		jedis.flushAll(); //清空所有的redis缓存
		jedis.lpush("list", "1","2","3","4");
		System.out.println(jedis.rpop("list"));
		
	}
	
	//控制事务
	@Test
	public void testTx(){
		//1.创建jedis对象
		Jedis jedis = new Jedis("192.168.126.129", 6379);
		jedis.flushAll(); //清空所有的redis缓存
		
		Transaction transaction = jedis.multi();		//2.开启事务
		try {
			transaction.set("aaa", "aaa");
			transaction.set("bbb", "bbbbb");
			transaction.set("ccc", "cccccc");
			transaction.exec();			//事务提交
		} catch (Exception e) {
			e.printStackTrace();
			transaction.discard();		//事务回滚
		}
	}
}
	

9.1.6 redis整合

说明:将jedis对象交给spring容器进行管理.之后哪里需要直接注入即可. 步骤:
1.编辑redis.properties文件,指定redis节点的ip:port
2.由于redis比较重要,很多业务系统都需要调用,所以将redis整合写入common
3.通过配置类(配置文件)形式整合redis.

编辑redis.properties文件

redis.host=192.168.126.129
redis.port=6379

编辑配置类

	@Configuration 	//我是一个配置类    一般都会与@Bean联用
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
	
	@Value("${redis.host}")
	private String host;
	@Value("${redis.port}")
	private Integer port;
	
	//将返回值的结果交给spring容器进行管理,如果以后想要使用该对象则可以直接注入.
	@Bean
	public Jedis jedis() {
		
		return new Jedis(host, port);
	}
	
}

json转化API

package com.jt.test;

import java.util.Date;

import org.junit.jupiter.api.Test;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jt.pojo.ItemDesc;

public class TestObjectMapper {
	
	//改对象就是工具api  有且只有一份即可.并且不允许别人修改.
	private static final ObjectMapper MAPPER = new ObjectMapper();
	/**
	 * 目的: 实现对象与json串之间的转化
	 * 步骤1:  将对象转化为json
	 * 步骤2:  将json转化为对象 
	 * 利用ObjectMapper 工具API实现
	 * @throws JsonProcessingException 
	 */
	@Test
	public void test01() throws JsonProcessingException {
		
		ItemDesc itemDesc = new ItemDesc();
		itemDesc.setItemId(101L).setItemDesc("json转化测试")
		.setCreated(new Date()).setUpdated(itemDesc.getCreated());
		
		//1.将对象转化为JSON   调用的是对象的get方法
		String json = MAPPER.writeValueAsString(itemDesc);
		System.out.println(json);
		
		//2.将json转化为对象   传递需要转化之后的class类型   调用是对象的set方法
		ItemDesc itemDesc2 = MAPPER.readValue(json, ItemDesc.class);
		System.out.println(itemDesc2.getItemDesc());
	}
}

9.1.7 AOP实现redis缓存

入门案例

//1.将对象交给容器管理
@Component
//2.定义aop切面
@Aspect
public class CacheAOP {
	
	//公式:   切面 = 切入点表达式 + 通知方法.
	/**
	 * 业务需求: 要求拦截ItemCatServiceImpl类中的业务
	 * @Pointcut 切入点表达式 可以理解为就是一个if判断,只有满足条件,才能执行通知方法.
	 */
	//@Pointcut("bean(itemCatServiceImpl)")  //按类匹配,控制的粒度较粗   单个bean
	//@Pointcut("within(com.jt.service..*)")  //按类匹配,控制的粒度较粗     多个bean
	@Pointcut("execution(* com.jt.service..*.*(..))") //细粒度的匹配方式
	public void pointCut() {
		
	}
	
	//joinPoint 方法执行切恰好被切入点表达式匹配,该方法的执行就称之为连接点.
	@Before("pointCut()")
	public void before(JoinPoint joinPoint) {
		System.out.println("我是前置通知!!!!");
		String typeName = 
				joinPoint.getSignature().getDeclaringTypeName();
		String methodName = joinPoint.getSignature().getName();
		Object[] objs = joinPoint.getArgs();
		Object target = joinPoint.getTarget();
		System.out.println("方法执行的全路径为:"+typeName+"."+methodName);
		System.out.println("获取方法参数:"+objs);
		System.out.println("获取目标对象:"+target);
	}
	
	
	//添加环绕通知  可以控制目标方法执行 要求添加参数
	@Around("pointCut()")
	public Object around(ProceedingJoinPoint joinPoint) {
		
		System.out.println("我是环绕通知开始");
		try {
			//Object result = joinPoint.proceed();
			System.out.println("我是环绕通知结束");
			return null;
		} catch (Throwable e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}  //指定目标方法
		
	}
	
}

实现AOP 缓存处理
自定义注解

@Target(ElementType.METHOD)	//标识注解 对谁生效
@Retention(RetentionPolicy.RUNTIME) //注解使用的有效期
public @interface CacheFind {
	
	public String key();			  //标识存入redis的key的前缀
	public int seconds() default 0;  //标识保存的时间 单位是秒
	
}

注解标识

AOP实现缓存业务处理

	package com.jt.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.jt.anno.CacheFind;
import com.jt.util.ObjectMapperUtil;

import redis.clients.jedis.Jedis;

//1.将对象交给容器管理
@Component
//2.定义aop切面
@Aspect
public class CacheAOP {
	
	@Autowired(required = false)
	private Jedis jedis;
	/**
	 * 实现思路:  拦截被@CacheFind标识的方法 之后利用aop进行缓存的控制
	 * 通知方法:  环绕通知
	 * 实现步骤:
	 * 		1.准备查询redis的key   ITEM_CAT_LIST::第一个参数
	 *      2.@annotation(cacheFind) 动态获取注解的语法.
	 *        拦截指定注解类型的注解并且将注解对象当做参数进行传递.
	 */
	@SuppressWarnings("unchecked")
	@Around("@annotation(cacheFind)")
	public Object around(ProceedingJoinPoint joinPoint,CacheFind cacheFind) {
		
		//1.获取用户注解中的key     ITEM_CAT_LIST::0
		String key = cacheFind.key();
		//2.动态获取第一个参数当做key
		String firstArg = joinPoint.getArgs()[0].toString();
		key += "::"+firstArg; 
		
		Object result = null;
		//3.根据key查询redis.
		if(jedis.exists(key)) {
			
			//根据redis获取数据信息
			String json = jedis.get(key);
			//如何获取返回值类型
			MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
			result = ObjectMapperUtil.toObject(json, methodSignature.getReturnType());
			System.out.println("aop查询redis缓存");
		}else {
			//如果key不存在,则证明是第一次查询.  应该查询数据库
			try {
				result = joinPoint.proceed(); //目标方法返回值
				System.out.println("AOP查询数据库获取返回值结果");
				//将数据保存到redis中
				String json = ObjectMapperUtil.toJSON(result);
				int seconds = cacheFind.seconds();
				if(seconds>0) 
					jedis.setex(key, seconds, json);
				else 
					jedis.set(key, json); 
				
			} catch (Throwable e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
		return result;
	}

	
	
	
	
	
	
	
	
	//公式:   切面 = 切入点表达式 + 通知方法.
	/**
	 * 业务需求: 要求拦截ItemCatServiceImpl类中的业务
	 * @Pointcut 切入点表达式 可以理解为就是一个if判断,只有满足条件,才能执行通知方法.
	 */
	/**
	//@Pointcut("bean(itemCatServiceImpl)")  //按类匹配,控制的粒度较粗   单个bean
	//@Pointcut("within(com.jt.service..*)")  //按类匹配,控制的粒度较粗     多个bean
	@Pointcut("execution(* com.jt.service..*.*(..))") //细粒度的匹配方式
	public void pointCut() {
		
	}
	
	//joinPoint 方法执行切恰好被切入点表达式匹配,该方法的执行就称之为连接点.
	@Before("pointCut()")
	public void before(JoinPoint joinPoint) {
		System.out.println("我是前置通知!!!!");
		String typeName = 
				joinPoint.getSignature().getDeclaringTypeName();
		String methodName = joinPoint.getSignature().getName();
		Object[] objs = joinPoint.getArgs();
		Object target = joinPoint.getTarget();
		System.out.println("方法执行的全路径为:"+typeName+"."+methodName);
		System.out.println("获取方法参数:"+objs);
		System.out.println("获取目标对象:"+target);
	}
	
	
	//添加环绕通知  可以控制目标方法执行 要求添加参数
	@Around("pointCut()")
	public Object around(ProceedingJoinPoint joinPoint) {
		
		System.out.println("我是环绕通知开始");
		try {
			//Object result = joinPoint.proceed();
			System.out.println("我是环绕通知结束");
			return null;
		} catch (Throwable e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}  //指定目标方法
		
	}
	**/
}

9.1.8 redis分片实现

1 为什么使用分片
1).说明: 虽然redis可以扩展内存空间的大小.但是如果需要存储海量的数据一味的扩大内存,其实效率不高.
2).分片介绍: 准备多台redis,共同为用户提供缓存服务.在保证效率的前提下,实现了内存的扩容.
用户在使用分片机制时,将多台redis当做1台使用.

9.1.8.1分片搭建

由3台redis构成 端口号分别为6379/6380/6381, 如果需要准备多台redis则准备多个配置文件即可,注意其中的端口号.

准备多台redis

说明:修改redis的配置文件的端口号

启动多台redis
命令:

[root@localhost shards]# redis-server 6379.conf & redis-server 6380.conf & redis-server 6381.conf &

9.1.8.2redis持久化策略

RDB模式
特点:
1.rdb模式是redis中默认的持久化策略.
2.rdb模式定期持久化.保存的是Redis中的内存数据快照.持久化文件占用空间较小.
3.rdb模式可能导致内存数据丢失

命令:
前提:需要在redis的客户端中执行.

1. save 命令 立即持久化 会导致其他操作陷入阻塞.
2. bgsave 命令 开启后台运行. 以异步的方式进行持久化. 不会造成其他操作的阻塞.

save 900 1        900秒内,如果用户执行的1次更新操作,则持久化一次
save 300 10		  300秒内,如果用户执行的10次更新操作,则持久化一次
save 60 10000	  60秒内,如果用户执行的10000次更新操作,则持久化一次
save 1 1	 	  1秒内,如果用户执行的1次更新操作,则持久化一次    set 阻塞!!!!

AOF模式
特点:
1). AOF模式默认条件下是关闭状态. 如果需要开启则需要修改配置文件.
2). AOF模式可以实现数据的实时持久化操作,AOF模式记录的是用户的操作过程.
3). 只要开启了AOF模式,则持久化方式以AOF模式为主.

配置多种持久化方式
1).设计 : 6379 当主机 7380当从机.
2).修改主机的配置文件:
要求: 主机使用RDB模式

从机使用AOF模式

检查默认模式的状态
命令: info replication

实现主从挂载
编辑从服务器向主机进行挂载

10.1 zookeeper下载安装

10.1.1安装

ZK下载

解压目录

tar -xvf zookeeper-3.4.8.tar.gz

10.1.2 配置文件修改

在zk根目录下创建文件夹data/log

跳入conf目录中修改配置文件
复制配置文件并且修改名称

cp zoo_sample.cfg zoo.cfg

10.1.3 启动ZK

跳转到bin目录中 zk启动关闭命令如下.

sh zkServer.sh start     或者  ./zkServer.sh start
sh zkServer.sh stop
sh zkServer.sh status

10.1.4 zookeeper集群安装

在zookeeper根目录中创建新的文件夹zkCluster.

创建zk1/zk2/zk3文件夹.

在每个文件夹里创建data/log文件夹.

命令

mkdir {zk1,zk2,zk3}/{data,log}

添加myid文件
分别在zk1/zk2/zk3中的data文件夹中创建新的文件myid.其中的内容依次为1/2/3,与zk节点号对应.

编辑配置文件
将zoo_sample.cfg 复制为zoo1.cfg之后修改配置文件.

修改zoo1.cfg文件

配置完成后将zoo1.cfg复制2份.之后需要修改对应的文件夹目录.和不同的端口即可.

10.1.5集群测试

通过下面的命令启动zk集群.

sh zkServer.sh start   zoo1.cfg
sh zkServer.sh stop    zoo1.cfg
sh zkServer.sh status  zoo1.cfg

检查主从关系

配置完成!!!

文件参考:
https://blog.csdn.net/qq_16804847/article/details/107504813