flyweight.go

  1. package flyweight
  2.  
  3. import (
  4. "time"
  5. )
  6.  
  7. const (
  8. TEAM_A = "A"
  9. TEAB_B = "B"
  10. )
  11.  
  12. type Team struct {
  13. ID uint64
  14. Name string
  15. Shield []byte
  16. Players []Player
  17. HistoricalData []HistoricalData
  18. }
  19.  
  20. type Player struct {
  21. Name string
  22. Surname string
  23. PerviousTeam uint64
  24. Photo []byte
  25. }
  26.  
  27. type HistoricalData struct {
  28. Year uint8
  29. LeagueResults []Match
  30. }
  31.  
  32. type Match struct {
  33. Date time.Time
  34. VisitorID uint64
  35. LocalID uint64
  36. LocalScore byte
  37. VisitorScore byte
  38. LocalShoots uint16
  39. VisitorShoots uint16
  40. }
  41.  
  42. type teamFlyweightFactory struct {
  43. createdTeams map[string]*Team
  44. }
  45.  
  46. func (t *teamFlyweightFactory) GetTeam(teamID string) *Team {
  47. if t.createdTeams[teamID] != nil {
  48. return t.createdTeams[teamID]
  49. }
  50.  
  51. team := getTeamFactory(teamID)
  52. t.createdTeams[teamID] = &team
  53. return t.createdTeams[teamID]
  54. }
  55.  
  56. func getTeamFactory(team string) Team {
  57. switch team {
  58. case TEAB_B:
  59. return Team{
  60. ID: 2,
  61. Name: TEAB_B,
  62. }
  63. default:
  64. return Team{
  65. ID: 1,
  66. Name: TEAM_A,
  67. }
  68. }
  69. }
  70.  
  71. func (t *teamFlyweightFactory) GetNumberOfObjects() int {
  72. return len(t.createdTeams)
  73. }
  74.  
  75. func NewTeamFactory() teamFlyweightFactory {
  76. return teamFlyweightFactory{
  77. createdTeams: make(map[string]*Team),
  78. }
  79. }

  

flyweight_test.go

  1. package flyweight
  2.  
  3. import (
  4. "fmt"
  5. "testing"
  6. )
  7.  
  8. func TestTeamFlyweightFactory_GetTeam(t *testing.T) {
  9. factory := NewTeamFactory()
  10.  
  11. teamA1 := factory.GetTeam(TEAM_A)
  12. if teamA1 == nil {
  13. t.Error("The pointer to the TEAM_A was nil")
  14. }
  15. teamA2 := factory.GetTeam(TEAM_A)
  16. if teamA2 == nil {
  17. t.Error("The pointer to the TEAM_A was nil")
  18. }
  19.  
  20. if teamA1 != teamA2 {
  21. t.Error("TEAM_A pointers weren't the same")
  22. }
  23.  
  24. if factory.GetNumberOfObjects() != 1 {
  25. t.Errorf("The number of objects created was not 1: %d\n", factory.GetNumberOfObjects())
  26. }
  27.  
  28. }
  29.  
  30. func Test_HighVolume(t *testing.T) {
  31. factory := NewTeamFactory()
  32. teams := make([]*Team, 5000*2)
  33. for i := 0; i < 5000; i++ {
  34. teams[i] = factory.GetTeam(TEAM_A)
  35. }
  36. for i := 5000; i < 2*5000; i++ {
  37. teams[i] = factory.GetTeam(TEAB_B)
  38. }
  39.  
  40. if factory.GetNumberOfObjects() != 2 {
  41. t.Errorf("The number of objects created was not 2: %d\n", factory.GetNumberOfObjects())
  42. }
  43.  
  44. for i := 0; i < 3; i++ {
  45. fmt.Printf("Pointer %d points to %p and is located in %p\n", i, teams[i], &teams[i])
  46. }
  47. }

  

go语言设计模式之Flyweight(享元模式)的更多相关文章

  1. 设计模式之flyweight享元模式

    运用共享技术支持大量细粒度对象的使用 Flyweight模式(享元) Java深入到一定程度,就不可避免的碰到设计模式这一概念,了解设计模式,将使自己对java中的接口或抽象类应用有更深的理解.设计模 ...

  2. 面向对象设计模式之Flyweight享元模式(结构型)

    动机:采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中,从而带来很高的运行代价——主要指内存需求方面的代价.如何在避免大量细粒度对象问题的同 时,让外部客户程序仍然能够透明地使用面向对象的 ...

  3. 设计模式(11)--Flyweight(享元模式)--结构型

    作者QQ:1095737364    QQ群:123300273     欢迎加入! 1.模式定义: 享元模式是对象的结构模式.享元模式以共享的方式高效地支持大量的细粒度对象. 2.模式特点: 享元模 ...

  4. Java设计模式:Flyweight(享元)模式

    概念定义 享元(Flyweight)模式运用共享技术高效地支持大量细粒度对象的复用. 当系统中存在大量相似或相同的对象时,有可能会造成内存溢出等问题.享元模式尝试重用现有的同类对象,如果未找到匹配的对 ...

  5. 设计模式11: Flyweight 享元模式(结构型模式)

    Flyweight 享元模式(结构型模式) 面向对象的代价 面向对象很好的解决了系统抽象性的问题,同时在大多数情况下也不会损及系统的性能.但是,在某些特殊应用中,由于对象的数量太大,采用面向对象会给系 ...

  6. C++设计模式-Flyweight享元模式

    Flyweight享元模式 作用:运用共享技术有效地支持大量细粒度的对象. 内部状态intrinsic和外部状态extrinsic: 1)Flyweight模式中,最重要的是将对象分解成intrins ...

  7. 20、FlyWeight 享元模式

    池化的思想 1.Flyweight享元模式 运用共享技术有效地支持大量细粒度对象的复用.系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用.由于享元模式要求能够共享的对象必 ...

  8. Java设计模式之《享元模式》及应用场景

    原创作品,可以转载,但是请标注出处地址:http://www.cnblogs.com/V1haoge/p/6542449.html 享元模式:"享"就是分享之意,指一物被众人共享, ...

  9. Flyweight享元模式(结构型模式)

    1.面向对象的缺点 虽然OOP能很好的解决系统抽象的问题,并且在大多数的情况下,也不会损失系统的性能.但是在某些特殊的业务下,由于对象的数量太多,采用面向对象会给系统带来难以承受的内存开销.示例代码如 ...

随机推荐

  1. VS Code Remote,在服务器上开发程序,开启全新开发模式

    一直使用Idea开发java 程序,头疼的是太太太占用内存了,笔记本电脑经常卡爆,在服务器开发的话又太麻烦,VS Code Remote的带来,解决了这一烦恼.下面来实战一下. VS Code Rem ...

  2. 灵魂拷问:创建 Java 字符串,用""还是构造函数

    在逛 programcreek 的时候,我发现了一些小而精悍的主题.比如说:创建 Java 字符串,用 "" 还是构造函数?像这类灵魂拷问的主题,非常值得深入地研究一下. 01.& ...

  3. C# -- RSA加密与解密

    1.  RSA加密与解密  --  使用公钥加密.私钥解密 public class RSATool { public string Encrypt(string strText, string st ...

  4. 大部分人都会忽略的Python易错点总结

    python中复数实现(-2) 0.5和开根号sqrt(-2)的区别** (-2)**0.5和sqrt(-2)是不同的,前者是复数后者是会报错的. print((-2)**0.5) #输出:(8.65 ...

  5. Linux(Centos7)下redis5安装、部署、开机自启

    1.什么是redis redis是用C语言开发的一个开源的高性能键值对(key-value)数据库.它通过提供多种键值数据类型来适应不同场景下的存储需求,目前为止redis支持的键值数据类型如下字符串 ...

  6. zhy2_rehat6_mysql04 - MHA_故障演示与切换.txt

    export LANG=en_US 环境:------------------------------------------ 机器 VPN ip linux 账号/密码manager1 172.28 ...

  7. CentOS 7上的程序管理:rpm、yum和源码编译安装

    简介 在Linux的早期时代(也许吧?我猜的.也可能是Unix.),想要在系统上安装一款应用程序,是比较复杂的.需要专业的人员自行获取程序的源代码,并且编译安装,这是非常的复杂且需要一定的专业功底的, ...

  8. 如何使用终端默认情况下阻止Mac应用保存到iCloud

    当您保存要在Mac上的Pages,Numbers,TextEdit或其他基于云的应用程序中处理的文档时,该保存的默认位置是iCloud.尽管这对某些人或某些文档来说可能是一件好事,但您可能会厌倦每次更 ...

  9. Ubuntu18.04 设置开机进入命令行模式

    首先来了解下启动级别(Runlevel): 指 Unix 或 类 Unix 操作系统下不同的运行模式,运行级别通常分为 7 级: 运行级别 0:系统停机状态,系统默认运行级别不能设为0,否则不能正常启 ...

  10. [译]Vulkan教程(24)索引buffer

    [译]Vulkan教程(24)索引buffer Index buffer 索引buffer Introduction 入门 The 3D meshes you'll be rendering in a ...