面试可能问的问题3

wsfhdhjs

已于 2023-02-07 23:48:25 修改

阅读量155

点赞数

分类专栏： java基础文章标签：面试数据库 mysql

于 2022-02-14 09:38:14 首次发布

本文链接：https://blog.csdn.net/wsfhdhjs/article/details/122917883

版权

java基础专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.读写分离

1.读写分离的前提是，mysql做了主从，也就是一主多从或者多主多从的结构

为什么要做读写分离？

1.应用的第一个瓶颈一定是在数据库（磁盘上的读写速度是最慢的）
2.写操作会加锁，也就是在进行读操作时必须等写操作完成之后再进行，加大的拖累了程序的运行速度
3.基本上所有的应用都是读多写少

2.MYSQL主从复制原理

mysql主从复制的基础是bin-log日志，slave通过一个I/O线程与主服务器保持通信，并监控master的二进制日志文件的变化，如果发现master二进制日志发生变化，则会把变化复制到自己的中继日志中，然后slave会通过一个SQL线程会把相关的"事件"执行到自己的数据库当中，以此实现了从数据库和主数据库的一致性，也就实现了主从复制。注意bin-log是可以做数据恢复的，所以生产环境一定要开启bin-log。其中master二进制日志文件就是bin-log。这个主要实现了，主库和从库保持一致！！！

binlog的日志格式

支持三种格式类型：
1.STATEMENT:基于SQL语句的复制
a.每一条会修改数据的sql语句都会存储在binlog中
b.有些函数在主从复制中不被识别
2.ROW：基于行的复制
a.不记录每一条SQL语句的上下文信息，只需要记录哪条数据被修改了，并且修改成什么样子了
b.会产生大量的日志文件
3.MIXED：混合模式复制
a.MYSQL会根据所执行的SQL语句来选择日志的保存方式
在MYSQL5.7.7之前，默认的格式是STATEMENT，在后来版本中，默认格式是ROW，格式通过binlog-format来确定

实现读写分离—ShardingSphere-JDBC

定位是轻量级的java框架，在java的JDBC层提供额外的服务。它使用客户端直连数据库，以jar包方式提供服务，无需额外的配置和依赖，可以理解为增强版的JDBC驱动
将数据库分为主库和从库，其中主库主要负责增删改，而从库负责读操作，能够有效的避免由数据库更新导致的行锁，可以提高系统的查询性能，采用一主多从的方式，可以将查询请求分散到多个数据副本，能够进一步提升系统的查询能力。读写分离根据sql语义分析，分别将读操作和写操作路由至主库和从库

shardingSphere-JDBC的配置

1.先配置一个总的数据源
2.配置一主多从数据库，master是主数据库，slave0和slave1是从数据库
3.分别对主数据和从数据库进行详细配置
4.写数据源名称
5.读数据源名称，多个从数据源用逗号进行分割
6.负载均衡算法名称：round-robin（轮询）。负载均衡算法的配置。select会走slave，insert，update会走master

1.先配置一个总的数据源
spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.common.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.common.username=root
spring.shardingsphere.datasource.common.password=wsf123

2.配置一主多从数据库，master是主数据库，slave0和slave1是从数据库
## ??2?
spring.shardingsphere.datasource.names=master,slave0,slave1

3.分别对主数据和从数据库进行详细配置
# ??? 1 ????
spring.shardingsphere.datasource.master.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.master.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.master.jdbc-url=jdbc:mysql://localhost:3306/xt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.shardingsphere.datasource.master.username=root
spring.shardingsphere.datasource.master.password=wsf123

# ??? 2 ????
spring.shardingsphere.datasource.slave0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.slave0.jdbc-url=jdbc:mysql://localhost:3306/xt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.shardingsphere.datasource.slave0.username=root
spring.shardingsphere.datasource.slave0.password=wsf123
# ??? 3 ????
spring.shardingsphere.datasource.slave1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.slave1.jdbc-url=jdbc:mysql://localhost:3306/xt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.shardingsphere.datasource.slave1.username=root
spring.shardingsphere.datasource.slave1.password=wsf123

# 写数据源名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.ms.write-data-source-name=master
# 读数据源名称，多个从数据源用逗号进行分割
spring.shardingsphere.rules.readwrite-splitting.data-sources.ms.read-data-source-names=slave0,slave1 
# 负载均衡算法名称：round-robin
spring.shardingsphere.rules.readwrite-splitting.data-sources.ms.load-balancer-name=round-robin

## ????????
spring.shardingsphere.rules.readwrite-splitting.load-balancers.round-robin.type=ROUND_ROBIN
## ??????????
spring.shardingsphere.rules.readwrite-splitting.load-balancers.round-robin.props.workId=1
#??sql
spring.shardingsphere.props.sql-show=true

#????
# ?? t_user_practice ???
spring.shardingsphere.rules.sharding.tables.t_user_practice.actual-data-nodes=master.t_user_practice_$->{0..9}

# ??????
spring.shardingsphere.rules.sharding.tables.t_user_practice.table-strategy.standard.sharding-column=user_id
spring.shardingsphere.rules.sharding.tables.t_user_practice.table-strategy.standard.sharding-algorithm-name=table-inline


# ?? ????
spring.shardingsphere.rules.sharding.sharding-algorithms.table-inline.type=INLINE
spring.shardingsphere.rules.sharding.sharding-algorithms.table-inline.props.algorithm-expression=t_user_practice_$->{user_id % 10}

习题（不同习题在一张表中实现）的数据库设计

对于选择题的不同选项，将选项化为一个json放到topic_choice中，使不同习题在一张表中实现
对于不同的题目，我们使用的是Excel模板将题目上传过去，其中不同的题目就是对应数据库中topic_type，对于选择题而言，就是1
在这里插入图片描述

在这里插入图片描述

填空题

在这里插入图片描述

判断题和回答题：

answer字段，对于判断题：0对1错

单选和多选

在这里插入图片描述

批量导入

POI工具类

package com.mszlu.xt.common.utils;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.multipart.MultipartFile;

public class POIUtils {
    private final static String xls = "xls";
    private final static String xlsx = "xlsx";
    private final static String DATE_FORMAT = "yyyy/MM/dd";
    /**
     * 读入excel文件，解析后返回
     * @param file
     * @throws IOException
     */
    public static List<String[]> readExcel(MultipartFile file) throws IOException {
        //检查文件
        checkFile(file);
        //获得Workbook工作薄对象
        Workbook workbook = getWorkBook(file);
        //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回
        List<String[]> list = new ArrayList<String[]>();
        if(workbook != null){
            for(int sheetNum = 0;sheetNum < workbook.getNumberOfSheets();sheetNum++){
                //获得当前sheet工作表
                Sheet sheet = workbook.getSheetAt(sheetNum);
                if(sheet == null){
                    continue;
                }
                //获得当前sheet的开始行
                int firstRowNum  = sheet.getFirstRowNum();
                //获得当前sheet的结束行
                int lastRowNum = sheet.getLastRowNum();
                //循环除了第一行的所有行
                for(int rowNum = firstRowNum+1;rowNum <= lastRowNum;rowNum++){
                    //获得当前行
                    Row row = sheet.getRow(rowNum);
                    if(row == null){
                        continue;
                    }
                    //获得当前行的开始列
                    int firstCellNum = row.getFirstCellNum();
                    //获得当前行的列数
                    int lastCellNum = row.getPhysicalNumberOfCells();
                    String[] cells = new String[row.getPhysicalNumberOfCells()];
                    //循环当前行
                    for(int cellNum = firstCellNum; cellNum < lastCellNum;cellNum++){
                        Cell cell = row.getCell(cellNum);
                        cells[cellNum] = getCellValue(cell);
                    }
                    list.add(cells);
                }
            }
            workbook.close();
        }
        return list;
    }

    //校验文件是否合法
    public static void checkFile(MultipartFile file) throws IOException{
        //判断文件是否存在
        if(null == file){
            throw new FileNotFoundException("文件不存在！");
        }
        //获得文件名
        String fileName = file.getOriginalFilename();
        //判断文件是否是excel文件
        if(!fileName.endsWith(xls) && !fileName.endsWith(xlsx)){
            throw new IOException(fileName + "不是excel文件");
        }
    }
    public static Workbook getWorkBook(MultipartFile file) {
        //获得文件名
        String fileName = file.getOriginalFilename();
        //创建Workbook工作薄对象，表示整个excel
        Workbook workbook = null;
        try {
            //获取excel文件的io流
            InputStream is = file.getInputStream();
            //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
            if(fileName.endsWith(xls)){
                //2003
                workbook = new HSSFWorkbook(is);
            }else if(fileName.endsWith(xlsx)){
                //2007
                workbook = new XSSFWorkbook(is);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return workbook;
    }
    public static String getCellValue(Cell cell){
        String cellValue = "";
        if(cell == null){
            return cellValue;
        }
        //如果当前单元格内容为日期类型，需要特殊处理
        String dataFormatString = cell.getCellStyle().getDataFormatString();
        if(dataFormatString != null && dataFormatString.equals("m/d/yy")){
            cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());
            return cellValue;
        }
        //把数字当成String来读，避免出现1读成1.0的情况
        if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
            cell.setCellType(Cell.CELL_TYPE_STRING);
        }
        //判断数据的类型
        switch (cell.getCellType()){
            case Cell.CELL_TYPE_NUMERIC: //数字
                cellValue = String.valueOf(cell.getNumericCellValue());
                break;
            case Cell.CELL_TYPE_STRING: //字符串
                cellValue = String.valueOf(cell.getStringCellValue());
                break;
            case Cell.CELL_TYPE_BOOLEAN: //Boolean
                cellValue = String.valueOf(cell.getBooleanCellValue());
                break;
            case Cell.CELL_TYPE_FORMULA: //公式
                cellValue = String.valueOf(cell.getCellFormula());
                break;
            case Cell.CELL_TYPE_BLANK: //空值
                cellValue = "";
                break;
            case Cell.CELL_TYPE_ERROR: //故障
                cellValue = "非法字符";
                break;
            default:
                cellValue = "未知类型";
                break;
        }
        return cellValue;
    }
}

习题录入到excel中

逻辑：读取excel，按照模板读取每行对应的数据，构建Topic对象，根据题目进行查询，如果有进行更新，如果没有进行插入
使用系统提供的POI工具类解决了大量习题的导入问题，也是系统提供的POI依赖
在这里插入图片描述

1.通过工具类读取文件，得到list数组，循环遍历数组，其中上传的文件类型是multipartFile
在这里插入图片描述

2.获取对应的单元，题目类型，题目
在这里插入图片描述

3.对应获得选项A，B，C，D，E
在这里插入图片描述

4.获取正确答案，解析，难度，区域，题目图片

在这里插入图片描述
5.new一个topic，将数据复制到topic中，去数据库再进行对比，如果不为空，则更新，否则就插入

TopicParam topic = new TopicParam();
                topic.setTopicTitle(topicTitle);
                topic.setTopicType(topicType);
                topic.setSubjectUnit(subjectUnit);
                topic.setTopicAnalyze(topicAnalyze);
                if (TopicType.FILL_BLANK.getCode() == topicType){
                    String[] strAnswer = topicAnswer.split("\\$;\\$");
                    List<Map<String,Object>> map = new ArrayList<>();
                    for (int i = 1;i<=strAnswer.length;i++){
                        Map<String,Object> m = new HashMap<>();
                        m.put("id",i);
                        m.put("content",strAnswer[i-1]);
                        map.add(m);
                    }
                    topic.setTopicChoice(JSON.toJSONString(map));
                }else{
                    topic.setTopicChoice(JSON.toJSONString(choiceList));
                }
                topic.setTopicAnswer(topicAnswer);

                topic.setCreateTime(System.currentTimeMillis());
                topic.setLastUpdateTime(System.currentTimeMillis());
                topic.setTopicStar(topicStar);
                topic.setTopicAreaCity(topicAreaCity);
                topic.setTopicImg(JSON.toJSONString(topicImageList));
                topic.setAddAdmin("admin");
                topic.setTopicAreaPro("");
                topic.setTopicSubject(subjectId);


                TopicModel t = this.topicService.findTopicByTitle(topic.getTopicTitle());
                if (t != null){
                    log.info("update topic:{}",topic.getTopicTitle());
                    topic.setId(t.getId());
                    updateNum++;
                    this.topicService.updateTopic(topic);
                }else{
                    this.topicService.saveTopic(topic);
                }
//
            }
//            System.out.println(JSON.toJSONString(list));
        } catch (IOException e) {
            e.printStackTrace();
            return CallResult.fail();
        }
        log.info("update num:{}",updateNum);
        return CallResult.success();
    }
}

POI工具类

package com.mszlu.xt.common.utils;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.multipart.MultipartFile;

public class POIUtils {
    private final static String xls = "xls";
    private final static String xlsx = "xlsx";
    private final static String DATE_FORMAT = "yyyy/MM/dd";
    /**
     * 读入excel文件，解析后返回
     * @param file
     * @throws IOException
     */
    public static List<String[]> readExcel(MultipartFile file) throws IOException {
        //检查文件
        checkFile(file);
        //获得Workbook工作薄对象
        Workbook workbook = getWorkBook(file);
        //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回
        List<String[]> list = new ArrayList<String[]>();
        if(workbook != null){
            for(int sheetNum = 0;sheetNum < workbook.getNumberOfSheets();sheetNum++){
                //获得当前sheet工作表
                Sheet sheet = workbook.getSheetAt(sheetNum);
                if(sheet == null){
                    continue;
                }
                //获得当前sheet的开始行
                int firstRowNum  = sheet.getFirstRowNum();
                //获得当前sheet的结束行
                int lastRowNum = sheet.getLastRowNum();
                //循环除了第一行的所有行
                for(int rowNum = firstRowNum+1;rowNum <= lastRowNum;rowNum++){
                    //获得当前行
                    Row row = sheet.getRow(rowNum);
                    if(row == null){
                        continue;
                    }
                    //获得当前行的开始列
                    int firstCellNum = row.getFirstCellNum();
                    //获得当前行的列数
                    int lastCellNum = row.getPhysicalNumberOfCells();
                    String[] cells = new String[row.getPhysicalNumberOfCells()];
                    //循环当前行
                    for(int cellNum = firstCellNum; cellNum < lastCellNum;cellNum++){
                        Cell cell = row.getCell(cellNum);
                        cells[cellNum] = getCellValue(cell);
                    }
                    list.add(cells);
                }
            }
            workbook.close();
        }
        return list;
    }

    //校验文件是否合法
    public static void checkFile(MultipartFile file) throws IOException{
        //判断文件是否存在
        if(null == file){
            throw new FileNotFoundException("文件不存在！");
        }
        //获得文件名
        String fileName = file.getOriginalFilename();
        //判断文件是否是excel文件
        if(!fileName.endsWith(xls) && !fileName.endsWith(xlsx)){
            throw new IOException(fileName + "不是excel文件");
        }
    }
    public static Workbook getWorkBook(MultipartFile file) {
        //获得文件名
        String fileName = file.getOriginalFilename();
        //创建Workbook工作薄对象，表示整个excel
        Workbook workbook = null;
        try {
            //获取excel文件的io流
            InputStream is = file.getInputStream();
            //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
            if(fileName.endsWith(xls)){
                //2003
                workbook = new HSSFWorkbook(is);
            }else if(fileName.endsWith(xlsx)){
                //2007
                workbook = new XSSFWorkbook(is);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return workbook;
    }
    public static String getCellValue(Cell cell){
        String cellValue = "";
        if(cell == null){
            return cellValue;
        }
        //如果当前单元格内容为日期类型，需要特殊处理
        String dataFormatString = cell.getCellStyle().getDataFormatString();
        if(dataFormatString != null && dataFormatString.equals("m/d/yy")){
            cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());
            return cellValue;
        }
        //把数字当成String来读，避免出现1读成1.0的情况
        if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
            cell.setCellType(Cell.CELL_TYPE_STRING);
        }
        //判断数据的类型
        switch (cell.getCellType()){
            case Cell.CELL_TYPE_NUMERIC: //数字
                cellValue = String.valueOf(cell.getNumericCellValue());
                break;
            case Cell.CELL_TYPE_STRING: //字符串
                cellValue = String.valueOf(cell.getStringCellValue());
                break;
            case Cell.CELL_TYPE_BOOLEAN: //Boolean
                cellValue = String.valueOf(cell.getBooleanCellValue());
                break;
            case Cell.CELL_TYPE_FORMULA: //公式
                cellValue = String.valueOf(cell.getCellFormula());
                break;
            case Cell.CELL_TYPE_BLANK: //空值
                cellValue = "";
                break;
            case Cell.CELL_TYPE_ERROR: //故障
                cellValue = "非法字符";
                break;
            default:
                cellValue = "未知类型";
                break;
        }
        return cellValue;
    }
}

分布式id

题目规模可能扩大，后面可能采用分表，所以将id使用分布式id
在这里插入图片描述

处理题目中有图片的

在这里插入图片描述

wsfhdhjs

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面试可能问的问题3

1.读写分离1.读写分离的前提是，mysql做了主从，也就是一主多从或者多主多从的结构为什么要做读写分离？1.应用的第一个瓶颈一定是在数据库（磁盘上的读写速度是最慢的）2.写操作会加锁，也就是在进行读操作时必须等写操作完成之后再进行，加大的拖累了程序的运行速度3.基本上所有的应用都是读多写少2.MYSQL主从复制原理mysql主从复制的基础是bin-log日志，slave通过一个I/O线程与主服务器保持通信，并监控master的二进制日志文件的变化，如果发现master二进制日志发生变化，则会
复制链接

扫一扫

专栏目录