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

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
  }
}

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

\\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]))

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
  }

（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("[email protected] [email protected]", (m => "*****" + m.group(2))))
}

二 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()
  }
}

（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)
  }
}

（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
  }
}

（4）Dao

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

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

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

}

（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
}

Controller层的特质

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

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

service层的特质

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

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

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
  }
}

（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()
  }
}

（7）Bean

无