目錄
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 中,這樣可以提高插入以及查詢的效率。