MySQL 學習記錄系列（六）

目錄

3、Mysql複製

3.1、複製

3.2、複製原理

3.3、複製優勢

3.4、搭建步驟

4.1、需求分析

4.3、通過AOP記錄操作日誌

4.4 日誌查詢後端代碼實現

4.5 日誌查詢前端代碼實現

4.6 聯調測試

4.7 分析性能問題

4.8 性能優化 - 分頁

4.9 性能優化 - 索引

4.10 性能優化 - 排序

4.11 性能優化 - 讀寫分離

4.12 性能優化 - 應用優化

---

3、Mysql複製

3.1、複製

複製是指將主數據庫的DDL和DML操作通過二進制日誌傳到從庫服務器中，然後在從庫上對這些日誌重新執行（也叫重做），從而使得從庫和主庫的數據保持同步。

MySQL支持一臺主庫同時向多臺從庫進行復制，從庫同時也可以作爲其他從服務器的主庫，實現鏈狀複製。

3.2、複製原理

MySQL的主從複製原理如下。

從上層來看，複製分成三步：

·Master 主庫在事務提交時，會把數據變更作爲時間Events 記錄在二進制日誌文件Binlog中。

·主庫推送二進制日誌文件Binlog中的日誌事件到從庫的中繼日誌RelayLog。

·slave重做中繼日誌中的事件，將改變反映它自己的數據。

3.3、複製優勢

MySQL 複製的有點主要包含以下三個方面：

• ·主庫出現問題，可以快速切換到從庫提供服務。
• ·可以在從庫上執行查詢操作，從主庫中更新，實現讀寫分離，降低主庫的訪問壓力。
• ·可以在從庫中執行備份，以避免備份期間影響主庫的服務。

3.4、搭建步驟

3.4.1、master

1）在master的配置文件（/etc/my.cnf）中，配置如下內容：

2）執行完畢之後，需要重啓Mysql：

systemctl restart mysqld

3）創建同步數據的賬戶，並且進行授權操作：

grant replication slave on *.* to ' root'@'192.168.192.131' identified by 'root';

flush privileges;

4）查看master狀態：

show master status

• File：從哪個日誌文件開始推送日誌文件
• Position：從哪個位置開始推送日誌
• Binlog_Ignore_DB：指定不需要同步的數據庫

3.4.2、slave

1）在slave 端配置文件中，配置如下內容：

2）執行完畢之後，需要重啓Mysql：

systemctl restart mysqld

3）執行如下指令：

change master to master-host='192.168.192.130', master_user=' root', master_password='root', master_log_file=' mysqlbin.000001', master_log_pos=413;

指定當前從庫對應的主庫的IP地址，用戶名，密碼，從哪個日誌文件開始的那個位置開始同步推送日誌。

4）開啓同步操作

start slave;

show slave status;

5）停止同步操作

stop slave；

3.4.3、驗證同步操作

1）在主庫中創建數據庫，創建表，並插入數據：

create database db01; 

user db01; 

create table user(
id int(11)not null auto_increment, 
name varchar(50)not nu11, 
sex varchar(1), 
primary key (id)
)engine=innodb default charset=utf8; 

insert into user(id,name,sex)values(null,'Tom','1'); 

insert into user(id,name,sex)values(null,'Trigger','0'); 

insert into user(id,name,sex)values(null,'Dawn','1');

2）在從庫中查詢數據，進行驗證：

在從庫中，可以查看到剛纔創建的數據庫：

在該數據庫中，查詢user表中的數據：

 

4.1、需求分析

在業務系統中，需要記錄當前業務系統的訪問日誌，該訪問日誌包含：操作人，操作時間，訪問類，訪問方法，請求參數，請求結果，請求結果類型，請求時長等信息。記錄詳細的系統訪問日誌，主要便於對系統中的用戶請求進行追蹤，並且在系統的管理後臺可以查看到用戶的訪問記錄。

記錄系統中的日誌信息，可以通過Spring框架的AOP來實現。具體的請求處理流程，如下：

CREATE TABLE brand(
id bigint(20) NOT NULL AUTO_INCREMENT,
name varchar(255)DEFAULT NULL COMMENT '品牌名稱',
first_char varchar(1) DEFAULT NULL COMMENT '品牌首字母',
PRIMARY KEY(id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE item(
id int(11)NOT NULL AUTO_INCREMENT COMMENT '商品id', 
title varchar(100)NOT NULL COMMENT '商品標題', 
price double(10, 2)NOT NULL COMMENT '商品價格, 單位爲：元', 
num int(10)NOT NULL COMMENT '庫存數量', 
categoryid bigint(10)NOT NULL COMMENT '所屬類目, 葉子類目', 
status varchar(1)DEFAULT NULL COMMENT '商品狀態, 1-正常, 2-下架, 3-刪除', 
sellerid varchar(50)DEFAULT NULL COMMENT '商家ID', 
createtime datetime DEFAULT NULL COMMENT '創建時間', 
updatetime datetime DEFAULT NULL COMMENT '更新時間', 
PRIMARY KEY(id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='商品表';

CREATE TABLE user(
id int(11)NOT NULL AUTO_INCREMENT,
username varchar(45)NOT NULL, 
password varchar(96)NOT NULL,
name varchar(45)NOT NULL, 
birthday datetime DEFAULT NULL, 
sex char(1)DEFAULT NULL, 
email varchar(45)DEFAULT NULL,
phone varchar(45)DEFAULT NULL, 
qq varchar(32)DEFAULT NULL, 
PRIMARY KEY(id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE operation_1og(
id bigint(20)NOT NULL AUTO_INCREMENT COMMENT 'ID', 
operate_class varchar(200)DEFAULT NULL COMMENT '操作類', 
operate_method varchar(200)DEFAULT NULL COMMENT '操作方法', 
return_class varchar(200)DEFAULT NULL COMMENT'返回值類型', 
operate_user varchar(20)DEFAULT NULL COMMENT '操作用戶', 
operate_time varchar(20)DEFAULT NULL COMMENT '操作時間', 
param_and_value varchar(500)DEFAULT NULL COMMENT '請求參數名及參數值', 
cost_time bigint(20)DEFAULT NULL COMMENT '執行方法耗時, 單位ms', 
return_value varchar(200)DEFAULT NULL COMMENT'返回值', 
PRIMARY KEY(id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

4.3、通過AOP記錄操作日誌

pom.xml

<properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <maven.compiler.source>1.7</maven.compiler.source>
 <maven.compiler.target>1.7</maven.compiler.target>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <maven.compiler.source>1.8</maven.compiler.source>
 <maven.compiler.target>1.8</maven.compiler.target>
 <spring.version>5.0.2.RELEASE</spring.version>
 <slf4j.version>1.6.6</slf4j.version>
 <log4j.version>1.2.12</log4j.version>
 <mybatis.version>3.4.5</mybatis.version>
</properties>
<dependencies> <!-- spring -->
 <dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.6.8</version>
 </dependency>
 <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.16.16</version>
 </dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-orm</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
 </dependency>
 <dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>
  <scope>provided</scope>
 </dependency>
 <dependency>
  <groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
  <version>2.0</version>
  <scope>provided</scope>
 </dependency>
 <dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>${log4j.version}</version>
 </dependency>
 <dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>${mybatis.version}</version>
 </dependency>
 <dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.0</version>
 </dependency>
 <dependency>
  <groupId>c3p0</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.1.2</version>
 </dependency>
 <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.5</version>
 </dependency>
 <dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.0</version>
 </dependency>
 <dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
 </dependency>
 <dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.0</version>
 </dependency>
</dependencies>
<build>
 <plugins>
  <plugin>
   <groupId>org.apache.tomcat.maven</groupId>
   <artifactId>tomcat7-maven-plugin</artifactId>
   <version>2.2</version>
   <configuration>
    <port>8080</port>
    <path>/</path>
    <uriEncoding>utf-8</uriEncoding>
   </configuration>
  </plugin>
 </plugins>
</build>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   version="2.5">
  <!-- 解決post亂碼 -->
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-
class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>utf-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
<listener-
class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-
class>
    <!-- 指定加載的配置文件 ，通過參數contextConfigLocation加載-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
   <welcome-file>log-datalist.html</welcome-file>
  </welcome-file-list>
</web-app>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.142.128:3306/mysql_demo
jdbc.username=root
jdbc.password=itcast

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
              http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
              http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
  <!-- 加載配置文件 -->
  <context:property-placeholder location="classpath:db.properties"/>
<!-- 配置 spring 創建容器時要掃描的包 -->
  <context:component-scan base-package="cn.itcast">
    <context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller">
    </context:exclude-filter>
  </context:component-scan>
  <!-- 配置 MyBatis 的 Session 工廠 -->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="typeAliasesPackage" value="cn.itcast.pojo"/>
  </bean>
  <!-- 配置數據源 -->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.url}"></property>
    <property name="user" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
  </bean>
  <!-- 配置 Mapper 掃描器 -->
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="cn.itcast.mapper"/>
  </bean>
  <!-- 配置事務管理器 -->
  <bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <!-- 配置事務的註解驅動 -->
  <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-
driven>
</beans>

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/mvc
      http://www.springframework.org/schema/mvc/spring-mvc.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="cn.itcast.controller">
</context:component-scan>
  <mvc:annotation-driven></mvc:annotation-driven>
  <aop:aspectj-autoproxy />
</beans>

4.3.1 自定義註解

通過自定義註解，來標示方法需不需要進行記錄日誌，如果該方法在訪問時需要記錄日誌，則在該方法上標示該注
解既可。

@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OperateLog {
}

4.3.2 定義通知類

@Component
@Aspect
public class OperateAdvice {
 private static Logger log = Logger.getLogger(OperateAdvice.class);
 @Autowired
 private OperationLogService operationLogService;
 @Around("execution(* cn.itcast.controller.*.*(..)) && @annotation(operateLog)")
 public Object insertLogAround(ProceedingJoinPoint pjp , OperateLog operateLog)
throws Throwable{
   System.out.println(" ************************ 記錄日誌 [start]
****************************** ");
  
   OperationLog op = new OperationLog();
  
   DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   op.setOperateTime(sdf.format(new Date()));
   op.setOperateUser(DataUtils.getRandStr(8));
  
   op.setOperateClass(pjp.getTarget().getClass().getName());
   op.setOperateMethod(pjp.getSignature().getName());
  
   //獲取方法調用時傳遞的參數
   Object[] args = pjp.getArgs();
   op.setParamAndValue(Arrays.toString(args));
   long start_time = System.currentTimeMillis();
   //放行
   Object object = pjp.proceed();
   long end_time = System.currentTimeMillis();
   op.setCostTime(end_time - start_time);
   if(object != null){
    op.setReturnClass(object.getClass().getName());
    op.setReturnValue(object.toString());
  }else{
    op.setReturnClass("java.lang.Object");
    op.setParamAndValue("void");
  }
   log.error(JsonUtils.obj2JsonString(op));
   operationLogService.insert(op);
System.out.println(" ************************** 記錄日誌 [end]
*************************** ");
  
   return object;
 }
}

4.3.3 方法上加註解

在需要記錄日誌的方法上加上註解@OperateLog。

@OperateLog
@RequestMapping("/insert")
public Result insert(@RequestBody Brand brand){
  try {
    brandService.insert(brand);
    return new Result(true,"操作成功");
 } catch (Exception e) {
    e.printStackTrace();
    return new Result(false,"操作失敗");
 }
}

4.4 日誌查詢後端代碼實現

4.4.1 Mapper接口

public interface OperationLogMapper {
  public void insert(OperationLog operationLog);
  public List<OperationLog> selectListByCondition(Map dataMap);
  public Long countByCondition(Map dataMap);
}

4.4.2 Mapper.xml 映射配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.itcast.mapper.OperationLogMapper" >
  <insert id="insert" parameterType="operationLog">
   INSERT INTO
operation_log(id,return_value,return_class,operate_user,operate_time,param_and_valu
e,
   operate_class,operate_method,cost_time)
VALUES(NULL,#{returnValue},#{returnClass},#{operateUser},#{operateTime},#
{paramAndValue},
   #{operateClass},#{operateMethod},#{costTime})
  </insert>
  <select id="selectListByCondition" parameterType="map"
resultType="operationLog">
  select
   id ,
   operate_class as operateClass ,
   operate_method as operateMethod,
   return_class as returnClass,
   operate_user as operateUser,
   operate_time as operateTime,
   param_and_value as paramAndValue,
   cost_time as costTime,
   return_value as returnValue
  from operation_log
   <include refid="oplog_where"/>
  limit #{start},#{size}
  </select>
  <select id="countByCondition" resultType="long" parameterType="map">
   select count(*) from operation_log
    <include refid="oplog_where"/>
  </select>
  <sql id="oplog_where">
    <where>
      <if test="operateClass != null and operateClass != '' ">
       and operate_class = #{operateClass}
      </if>
      <if test="operateMethod != null and operateMethod != '' ">
       and operate_method = #{operateMethod}
      </if>
      <if test="returnClass != null and returnClass != '' ">
       and return_class = #{returnClass}
      </if>
      <if test="costTime != null">
       and cost_time = #{costTime}
      </if>
    </where>
  </sql>
</mapper>

4.4.3 Service

@Service
@Transactional
public class OperationLogService {
//private static Logger logger = Logger.getLogger(OperationLogService.class);
  @Autowired
  private OperationLogMapper operationLogMapper;
  //插入數據
  public void insert(OperationLog operationLog){
    operationLogMapper.insert(operationLog);
 }
  //根據條件查詢
  public PageResult selectListByCondition(Map dataMap, Integer pageNum , Integer
pageSize){
   if(paramMap ==null){
      paramMap = new HashMap();
   }
    paramMap.put("start" , (pageNum-1)*rows);
    paramMap.put("rows",rows);
    Object costTime = paramMap.get("costTime");
    if(costTime != null){
      if("".equals(costTime.toString())){
        paramMap.put("costTime",null);
     }else{
        paramMap.put("costTime",new
Long(paramMap.get("costTime").toString()));
     }
   }
    System.out.println(dataMap);
    long countStart = System.currentTimeMillis();
    Long count = operationLogMapper.countByCondition(dataMap);
    long countEnd = System.currentTimeMillis();
    System.out.println("Count Cost Time : " + (countEnd-countStart)+" ms");
    List<OperationLog> list =
operationLogMapper.selectListByCondition(dataMap);
    long queryEnd = System.currentTimeMillis();
    System.out.println("Query Cost Time : " + (queryEnd-countEnd)+" ms");
    return new PageResult(count,list);
 }
}

4.4.4 Controller

@RestController
@RequestMapping("/operationLog")
public class OperationLogController {
  @Autowired
  private OperationLogService operationLogService;
  @RequestMapping("/findList")
  public PageResult findList(@RequestBody Map dataMap, Integer pageNum , Integer
pageSize){
    PageResult page = operationLogService.selectListByCondition(dataMap,
pageNum, pageSize);
    return page;
 }
}

4.5 日誌查詢前端代碼實現

前端代碼使用 BootStrap + AdminLTE 進行佈局， 使用Vuejs 進行視圖層展示。

4.5.1 js

<script>
 var vm = new Vue({
   el: '#app',
   data: {
     dataList:[],
     searchEntity:{
       operateClass:'',
       operateMethod:'',
       returnClass:'',
       costTime:''
     },
     page: 1,  //顯示的是哪一頁
     pageSize: 10, //每一頁顯示的數據條數
     total: 150, //記錄總數
     maxPage:8  //最大頁數
   },
   methods: {
     pageHandler: function (page) {
       this.page = page;
       this.search();
     },
     search: function () {
       var _this = this;
       this.showLoading();
       axios.post('/operationLog/findList.do?pageNum=' + _this.page +
"&pageSize=" + _this.pageSize, _this.searchEntity).then(function (response) {
if (response) {
           _this.dataList = response.data.dataList;
           _this.total = response.data.total;
           _this.hideLoading();
         }
       })
     },
     showLoading: function () {
       $('#loadingModal').modal({backdrop: 'static', keyboard: false});
     },
     hideLoading: function () {
       $('#loadingModal').modal('hide');
     },
   },
   created:function(){
     this.pageHandler(1);
   }
 });
</script>

4.5.2 列表數據展示

<tr v-for="item in dataList">
  <td><input name="ids" type="checkbox"></td>
  <td>{{item.id}}</td>
  <td>{{item.operateClass}}</td>
  <td>{{item.operateMethod}}</td>
  <td>{{item.returnClass}}</td>
  <td>{{item.returnValue}}</td>
  <td>{{item.operateUser}}</td>
  <td>{{item.operateTime}}</td>
  <td>{{item.costTime}}</td>
  <td class="text-center">
    <button type="button" class="btn bg-olive btn-xs">詳情</button>
    <button type="button" class="btn bg-olive btn-xs">刪除</button>
  </td>
</tr>

4.5.3 分頁插件

<div class="wrap" id="wrap">
  <zpagenav v-bind:page="page" v-bind:page-size="pageSize" v-bind:total="total"
       v-bind:max-page="maxPage"  v-on:pagehandler="pageHandler">
  </zpagenav>
</div>

4.6 聯調測試

可以通過postman來訪問業務系統，再查看數據庫中的日誌信息，驗證能不能將用戶的訪問日誌記錄下來。

4.7 分析性能問題

系統中用戶訪問日誌的數據量，隨着時間的推移，這張表的數據量會越來越大，因此需要根據業務需求，來對
日誌查詢模塊的性能進行優化。

1） 分頁查詢優化

由於在進行日誌查詢時，是進行分頁查詢，那也就意味着，在查看時，至少需要查詢兩次：

• A. 查詢符合條件的總記錄數。--> count 操作
• B. 查詢符合條件的列表數據。--> 分頁查詢 limit 操作

通常來說，count() 都需要掃描大量的行（意味着需要訪問大量的數據）才能獲得精確的結果，因此是很難對該
SQL進行優化操作的。

如果需要對count進行優化，可以採用另外一種思路，可以增加彙總表，或者redis緩存來專門記錄該表對應的記錄數，這樣的話，就可以很輕鬆的實現彙總數據的查詢，而且效率很高，但是這種統計並不能保證百分之百的準確 。

對於數據庫的操作，“快速、精確、實現簡單”，三者永遠只能滿足其二，必須舍掉其中一
個。

2） 條件查詢優化

針對於條件查詢,需要對查詢條件,及排序字段建立索引。

3） 讀寫分離

通過主從複製集羣，來完成讀寫分離，使寫操作走主節點， 而讀操作，走從節點。

4） MySQL服務器優化

5） 應用優化

4.8 性能優化 - 分頁

4.8.1 優化count

創建一張表用來記錄日誌表的總數據量：

create table log_counter(
logcount bigint not null
)engine = innodb default CHARSET = utf8;

在每次插入數據之後，更新該表 ：

<update id="updateLogCounter" >
 update log_counter set logcount = logcount + 1
</update>

在進行分頁查詢時, 獲取總記錄數，從該表中查詢既可。

<select id="countLogFromCounter" resultType="long">
 select logcount from log_counter limit 1
</select>

4.8.2 優化 limit

在進行分頁時，一般通過創建覆蓋索引，能夠比較好的提高性能。一個非常常見，而又非常頭疼的分頁場景就是
"limit 1000000,10" ，此時MySQL需要搜索出前1000010 條記錄後，僅僅需要返回第 1000001 到 1000010 條記
錄，前1000000 記錄會被拋棄，查詢代價非常大

當點擊比較靠後的頁碼時，就會出現這個問題，查詢效率非常慢。

優化SQL：

select * from operation_log limit 3000000 , 10; 

將上述SQL優化爲 :

select * from operation_log t , (select id from operation_log order by id limit
3000000,10) b where t.id = b.id ;

<select id="selectListByCondition" parameterType="map" resultType="operationLog"> 
select
 id ,
 operate_class as operateClass ,
 operate_method as operateMethod,
 return_class as returnClass,
 operate_user as operateUser,
 operate_time as operateTime,
 param_and_value as paramAndValue,
 cost_time as costTime,
 return_value as returnValue
from operation_log t,
 
(select id from operation_log
 <where>
  <include refid="oplog_where"/>
 </where>
order by id limit #{start},#{rows}) b where t.id = b.id 
</select>

4.9 性能優化 - 索引

當根據操作人進行查詢時， 查詢的效率很低，耗時比較長。原因就是因爲在創建數據庫表結構時，並沒有針對於
操作人 字段建立索引。

CREATE INDEX idx_user_method_return_cost ON
operation_log(operate_user,operate_method,return_class,cost_time);

同上 ， 爲了查詢效率高，也需要對 操作方法、返回值類型、操作耗時 等字段進行創建索引，以提高查詢效
率。

CREATE INDEX idx_optlog_method_return_cost ON
operation_log(operate_method,return_class,cost_time);
CREATE INDEX idx_optlog_return_cost ON operation_log(return_class,cost_time);
CREATE INDEX idx_optlog_cost ON operation_log(cost_time);

4.10 性能優化 - 排序

在查詢數據時，如果業務需求中需要對結果內容進行了排序處理 , 還需要對排序的字段建立適當的索引, 來提高排序的效率 。

4.11 性能優化 - 讀寫分離

4.11.1 概述

在Mysql主從複製的基礎上，可以使用讀寫分離來降低單臺Mysql節點的壓力，從而來提高訪問效率，讀寫分離的
架構如下：

對於讀寫分離的實現，可以通過Spring AOP 來進行動態的切換數據源，進行操作 ：

4.11.2 實現方式

db.properties

jdbc.write.driver=com.mysql.jdbc.Driver
jdbc.write.url=jdbc:mysql://192.168.142.128:3306/mysql_demo
jdbc.write.username=root
jdbc.write.password=root
jdbc.read.driver=com.mysql.jdbc.Driver
jdbc.read.url=jdbc:mysql://192.168.142.129:3306/mysql_demo
jdbc.read.username=root
jdbc.read.password=root

applicationContext-datasource.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
  <!-- 配置數據源 - Read -->
  <bean id="readDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close"  lazy-init="true">
    <property name="driverClass" value="${jdbc.read.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.read.url}"></property>
    <property name="user" value="${jdbc.read.username}"></property>
    <property name="password" value="${jdbc.read.password}"></property>
  </bean>
  <!-- 配置數據源 - Write -->
  <bean id="writeDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
 destroy-method="close"  lazy-init="true">
    <property name="driverClass" value="${jdbc.write.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.write.url}"></property>
    <property name="user" value="${jdbc.write.username}"></property>
    <property name="password" value="${jdbc.write.password}"></property>
  </bean>
  <!-- 配置動態分配的讀寫 數據源 -->
  <bean id="dataSource" class="cn.itcast.aop.datasource.ChooseDataSource" lazy-
init="true">
    <property name="targetDataSources">
      <map key-type="java.lang.String" value-type="javax.sql.DataSource">
        <entry key="write" value-ref="writeDataSource"/>
        <entry key="read" value-ref="readDataSource"/>
      </map>
    </property>
    <property name="defaultTargetDataSource" ref="writeDataSource"/>
    <property name="methodType">
      <map key-type="java.lang.String">
        <entry key="read" value=",get,select,count,list,query,find"/>
        <entry key="write"
value=",add,create,update,delete,remove,insert"/>
      </map>
</property>
  </bean>
</beans>

ChooseDataSource

public class ChooseDataSource extends AbstractRoutingDataSource {
  public static Map<String, List<String>> METHOD_TYPE_MAP = new HashMap<String,
List<String>>();
  /**
  * 實現父類中的抽象方法，獲取數據源名稱
  * @return
  */
  protected Object determineCurrentLookupKey() {
    return DataSourceHandler.getDataSource();
 }
  // 設置方法名前綴對應的數據源
  public void setMethodType(Map<String, String> map) {
    for (String key : map.keySet()) {
      List<String> v = new ArrayList<String>();
      String[] types = map.get(key).split(",");
      for (String type : types) {
        if (!StringUtils.isEmpty(type)) {
          v.add(type);
       }
     }
      METHOD_TYPE_MAP.put(key, v);
   }
    System.out.println("METHOD_TYPE_MAP : "+METHOD_TYPE_MAP);
 }
}

DataSourceHandler

public class DataSourceHandler {
  // 數據源名稱
  public static final ThreadLocal<String> holder = new ThreadLocal<String>();
  /**
  * 在項目啓動的時候將配置的讀、寫數據源加到holder中
  */
  public static void putDataSource(String datasource) {
    holder.set(datasource);
 }
  /**
  * 從holer中獲取數據源字符串
*/
  public static String getDataSource() {
    return holder.get();
 }
}

DataSourceAspect

@Aspect
@Component
@Order(-9999)
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class DataSourceAspect {
  protected Logger logger = LoggerFactory.getLogger(this.getClass());
  /**
  * 配置前置通知,使用在方法aspect()上註冊的切入點
  */
  @Before("execution(* cn.itcast.service.*.*(..))")
  @Order(-9999)
  public void before(JoinPoint point) {
   
    String className = point.getTarget().getClass().getName();
    String method = point.getSignature().getName();
    logger.info(className + "." + method + "(" +
Arrays.asList(point.getArgs())+ ")");
    try {
      for (String key : ChooseDataSource.METHOD_TYPE_MAP.keySet()) {
        for (String type : ChooseDataSource.METHOD_TYPE_MAP.get(key)) {
          if (method.startsWith(type)) {
            System.out.println("key : " + key);
            DataSourceHandler.putDataSource(key);
            break;
         }
       }
     }
   } catch (Exception e) {
      e.printStackTrace();
   }
 }
}

通過 @Order(-9999) 註解來控制事務管理器, 與該通知類的加載順序 , 需要讓通知類 , 先加載 , 來判定使用哪個數據
源 .

4.11.3 驗證

在主庫和從庫中，執行如下SQL語句，來查看是否讀的時候， 從從庫中讀取 ； 寫入操作的時候，是否寫入到主
庫。

show status like 'Innodb_rows_%' ; 

4.11.4 原理

4.12 性能優化 - 應用優化

4.12.1 緩存

可以在業務系統中使用redis來做緩存，緩存一些基礎性的數據，來降低關係型數據庫的壓力，提高訪問效率。

4.12.2 全文檢索

如果業務系統中的數據量比較大（達到千萬級別），這個時候，如果再對數據庫進行查詢，特別是進行分頁查詢，
速度將變得很慢（因爲在分頁時首先需要count求合計數），爲了提高訪問效率，這個時候，可以考慮加入Solr 或
者 ElasticSearch全文檢索服務，來提高訪問效率

4.13.3 非關係數據庫

也可以考慮將非核心（重要）數據，存在 MongoDB 中，這樣可以提高插入以及查詢的效率。