• Scala基础【正则表达式、框架式开发原则】

    文章目录

    一 正则表达式

    1 介绍

    正则表达式和模式匹配很像

    模式匹配匹配的是规则：类型，常量，元组，集合，数组，对象，参数

    正则表达式匹配的也是规则：String

    正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    2 基本语法

    def main(args: Array[String]): Unit = {
  //声明规则
  val regex = "a".r
  //准备数据
  val data = "zhangsan"
  //使用规则校验数据
  val maybeString: Option[String] = regex.findFirstIn(data)
  if(maybeString.isEmpty){
    println("字符串不匹配规则")
  }else{
    println("字符串匹配规则：" + maybeString.get)
  }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    3 案例

    （1）验证手机号

    不使用正则表达式判断一个字符串是不是电话号码（部分功能）

    def main(args: Array[String]): Unit = {
  println(checkTel("xxxxxxxxxxx"))
  println(checkTel("11111111111"))
}
def checkTel(tel : String) : Boolean ={
  if(tel.size == 11){
    var r = true
    Breaks.breakable{
      for(c <- tel){
        try{
          c.toString.toInt
        }catch {
          case e : Exception => {
            r = false
            Breaks.break()
          }
        }
      }
    }
    r
  }else{
    false
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    使用正则表达式判断一个字符串是不是电话号码

    \\d：表示字符串中有一个数字就行
^：表示字符串的开始位置
$：表示字符串的结束位置
^\\d$：字符串从头到尾只有一个数字
^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d$：匹配十一个数字
^\d{11}$：数字重复11次
[0-9]：类似于\\d
a|b：a，b两个条件满足之一即可
((13[0-9])|		13开头，后一位为0-9任何数字都可以
(14[5,7,9])|	14开头，后一位为5,7,9都可以
(15[^4])|		15开头，后一位不包括数字
(18[0-9])|		
(17[0,1,3,5,6,7,8]))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    def main(args: Array[String]): Unit = {
    // 构建正则表达式
    println(isMobileNumber("18801234567"))
    println(isMobileNumber("11111111111"))
  }
  def isMobileNumber(number: String): Boolean ={
    val regex = "^((13[0-9])|(14[5,7,9])|(15[^4])|(18[0-9])|(17[0,1,3,5,6,7,8]))[0-9]{8}$".r
    val length = number.length
    regex.findFirstMatchIn(number.slice(length-11,length)) != None
  }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    （2）提取邮件地址

    def main(args: Array[String]): Unit = {
  // 构建正则表达式
  val r = """([_A-Za-z0-9-]+(?:\.[_A-Za-z0-9-\+]+)*)(@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*(?:\.[A-Za-z]{2,})) ?""".r
  println(r.replaceAllIn("abc.edf+jianli@gmail.com   hello@gmail.com.cn", (m => "*****" + m.group(2))))
}

    • 1
    • 2
    • 3
    • 4
    • 5

    二 WordCount框架式开发规则

    1 架构模式

    （1）MVC

    MVC：Model View Controller，将代码强制分解为三个组成部分，模型、视图、控制器

    模型：分为数据模型和业务模型

    视图：用户看到的界面

    控制器：调度器，调度视图，业务和数据之间的关系

    针对B/S结构的服务

    （2）三层架构

    Controller：控制器

    Service：逻辑服务，对应模型中的业务模型

    DAO：Data Acess Object，对应模型中的数据模型

    出现问题方便处理，增强扩展性，降低耦合性

    请求先访问控制器，由控制器找到对应的service，再由service访问DAO，层层递进，依次返回结果

    2 代码实现

    调用关系： TApplication – TController – TService – TDao

    ​ Application – Controller – Service – Dao

    ​ Util

    （1）Application

    package com.hike.bigdata.scala.summer.application

import com.hike.bigdata.scala.summer.common.TApplication
import com.hike.bigdata.scala.summer.controller.WordCountController

object WordCountApplication extends App with TApplication {

  execute {
    //将用户请求传递给Controller层
    val controller = new WordCountController
    //获取从Controller层传回的结果
    controller.dispatch()
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    （2）Controller

    package com.hike.bigdata.scala.summer.controller

import com.hike.bigdata.scala.summer.common.TController
import com.hike.bigdata.scala.summer.service.WordCountService

class WordCountController extends TController {

  // private：只在controller层中访问service层
  // Controller调度Service层
  private val wordCountService = new WordCountService

  def dispatch(): Unit = {

    //获取service层获得结果，输出到控制台
    val wordCount: Map[String, Int] = wordCountService.analysis()
    println(wordCount)
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    （3）Service

    package com.hike.bigdata.scala.summer.service

import com.hike.bigdata.scala.summer.common.TService
import com.hike.bigdata.scala.summer.dao.WordCountDao

class WordCountService extends TService {
  //只在service层中访问DAO层
  //Service层访问Dao层
  private val WordCountDao = new WordCountDao

  def analysis() = {

    // 从dao层获取文件内容，执行代码逻辑
    // 返回结果WordCount
    val lines = WordCountDao.readFile("data/word.txt")

    val words = lines.flatMap(
      line => line.split(" ")
    )
    val wordGroup = words.groupBy(word => word)
    val wordCount = wordGroup.mapValues(
      v => v.size
    )
    wordCount
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    （4）Dao

    package com.hike.bigdata.scala.summer.dao

import com.hike.bigdata.scala.summer.common.TDao

//使用抽象类中的方法
class WordCountDao extends TDao {

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    （5）Common

    Application层的特质

    package com.hike.bigdata.scala.summer.common

import com.hike.bigdata.scala.summer.util.EnvCache

//抽取Application层的通用方法
trait TApplication {
  def execute(op: => Unit): Unit = {
    //将系统配置发送到共享区域
    EnvCache.put("e:/")
    println("开启环境")
    //执行代码逻辑
    try {
      op
    } catch {
      case e: Exception => e.printStackTrace()
    }
    println("释放环境")
    EnvCache.clear()
  }

  //  def execute(): Unit ={
  //    //模板方法设计模式，一般以do开头
  //    println("开启环境")
  //
  //    try{
  //      doExecute()
  //    }catch {
  //      case e: Exception => e.printStackTrace()
  //    }
  //    println("释放环境")
  //  }
  //  def doExecute():Unit
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    Controller层的特质

    package com.hike.bigdata.scala.summer.common

//Controller层的运行方法，由实现类实现
trait TController {
  def dispatch(): Unit
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    service层的特质

    package com.hike.bigdata.scala.summer.common

//service层的执行方法，由实现类实现
trait TService {
  def analysis(): Any
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    Dao层的特质

    package com.hike.bigdata.scala.summer.common

import com.hike.bigdata.scala.summer.util.EnvCache

import scala.io.{BufferedSource, Source}

trait TDao {
  //读取文件，返回文件内容
  def readFile(path: String) = {
    //EnvCache.get获取文件根目录
    val source: BufferedSource = Source.fromFile(EnvCache.get() + path)
    val lines = source.getLines().toList
    source.close()
    lines
  }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    （6）Util

    package com.hike.bigdata.scala.summer.util

object EnvCache {
  //在线程中开辟一块空间，这个空间内的数据可以供任意层取出
  //ThreadLocal不能解决线程安全问题，只是共享数据
  private val envCache: ThreadLocal[Object] = new ThreadLocal[Object]

  def put(data: Object): Unit = {
    envCache.set(data)
  }

  def get() = {
    envCache.get()
  }

  def clear(): Unit = {
    envCache.remove()
  }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    （7）Bean

    无

  • 相关阅读:
    单商户商城系统功能拆解39—分销应用—分销等级
    webpack分环境打包（生产/开发两套打包）
    TypeScript
    C语言面试必看-指针笔试题详解
    51单片机中断和定时的结合应用
    数据特征工程 | 主成分分析（Python）
    三、《任务列表案例》前端程序搭建和运行
    信奥中的数学基础：因式分解
    线程安全问题以及其解决方法
    Debian11之基于kubeadm安装K8S集群
  • 原文地址：https://blog.csdn.net/weixin_43923463/article/details/126144417