20.综合案例(2)-性能优化

作者: 21号新秀_邓肯 | 来源:发表于2021-02-20 05:32 被阅读0次

7.分析性能问题

系统中用户访问日志的数据量，随着时间的推移，这张表的数据量会越来越大，因此我们需要根据业务需求，来对日志查询模块的性能进行优化。

1）分页查询优化
由于在进行日志查询时，是进行分页查询，那也就意味着，在查看时，至少需要查询两次：
A. 查询符合条件的总记录数。--> count 操作
B. 查询符合条件的列表数据。--> 分页查询 limit 操作
通常来说，count() 都需要扫描大量的行（意味着需要访问大量的数据）才能获得精确的结果，因此是很难对该SQL进行优化操作的。如果需要对count进行优化，可以采用另外一种思路，可以增加汇总表，或者redis缓存来专门记录该表对应的记录数，这样的话，就可以很轻松的实现汇总数据的查询，而且效率很高，但是这种统计并不能保证百分之百的准确。对于数据库的操作，“快速、精确、实现简单”，三者永远只能满足其二，必须安徽w.舍掉其中一个。

2）条件查询优化
针对于条件查询,需要对查询条件,及排序字段建立索引。

3）读写分离
通过主从复制集群，来完成读写分离，使写操作走主节点，而读操作，走从节点。

4） MySQL服务器优化

5）应用优化

8. 性能优化 - 分页

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>

8.2 优化limit

在进行分页时，一般通过创建覆盖索引，能够比较好的提高性能。一个非常常见，而又非常头疼的分页场景就是"limit 1000000,10" ，此时MySQL需要搜索出前1000010 条记录后，仅仅需要返回第 1000001 到 1000010 条记录，前1000000 记录会被抛弃，查询代价非常大。

image.png

当点击比较靠后的页码时，就会出现这个问题，查询效率非常慢。

优化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>

9. 性能优化 - 索引

image.png

当根据操作人进行查询时，查询的效率很低，耗时比较长。原因就是因为在创建数据库表结构时，并没有针对于操作人字段建立索引

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);

10. 性能优化 - 排序

在查询数据时，如果业务需求中需要我们对结果内容进行了排序处理 , 这个时候,我们还需要对排序的字段建立适当的索引, 来提高排序的效率

11.性能优化 - 读写分离

11.1 概述

在Mysql主从复制的基础上，可以使用读写分离来降低单台Mysql节点的压力，从而来提高访问效率，读写分离的架构如下：

image.png

对于读写分离的实现，可以通过Spring AOP 来进行动态的切换数据源，进行操作：

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=itcast

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=itcast

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) 注解来控制事务管理器, 与该通知类的加载顺序 , 需要让通知类 , 先加载 , 来判定使用哪个数据源

11.3 验证

在主库和从库中，执行如下SQL语句，来查看是否读的时候，从从库中读取；写入操作的时候，是否写入到主库

show status like 'Innodb_rows_%' ;

image.png

11.4 原理

image.png

12. 性能优化 - 应用优化

12.1 缓存

可以在业务系统中使用redis来做缓存，缓存一些基础性的数据，来降低关系型数据库的压力，提高访问效率

12.2 全文检测

如果业务系统中的数据量比较大（达到千万级别），这个时候，如果再对数据库进行查询，特别是进行分页查询，速度将变得很慢（因为在分页时首先需要count求合计数），为了提高访问效率，这个时候，可以考虑加入Solr 或者 ElasticSearch全文检索服务，来提高访问效率。

12.3 非关系数据库

也可以考虑将非核心（重要）数据，存在 MongoDB 中，这样可以提高插入以及查询的效率

20.综合案例(2)-性能优化

7.分析性能问题

8. 性能优化 - 分页

8.1 优化count

8.2 优化limit

9. 性能优化 - 索引

10. 性能优化 - 排序

11.性能优化 - 读写分离

11.1 概述

11.2 实现方式

11.3 验证

11.4 原理

12. 性能优化 - 应用优化

12.1 缓存

12.2 全文检测

12.3 非关系数据库

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读