abstractfactory.go
最后更新于：2022-04-02 04:48:14
~~~
/*
Abstract Factory 抽象工厂模式：
提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类
个人想法：工厂模式和抽象工厂模式：感觉抽象工厂可以叫集团模式，工厂模式下，
是一个工厂下，对产品的每一个具体生成分配不同的流水线；
集团模式：在集团下，有不同的工厂，可以生成不同的产品，
每个工厂生产出来的同一个型号产品具体细节是不一样
作者： HCLAC
日期： 20170306
*/
package abstractfactory
import (
"fmt"
)
type User struct {
id int
name string
}
func (u *User) Id() int {
if u == nil {
return -1
}
return u.id
}
func (u *User) SetId(id int) {
if u == nil {
return
}
u.id = id
}
func (u *User) Name() string {
if u == nil {
return ""
}
return u.name
}
func (u *User) SetName(name string) {
if u == nil {
return
}
u.name = name
}
type Department struct {
id int
name string
}
func (d *Department) Id() int {
if d == nil {
return -1
}
return d.id
}
func (d *Department) SetId(id int) {
if d == nil {
return
}
d.id = id
}
func (d *Department) Name() string {
if d == nil {
return ""
}
return d.name
}
func (d *Department) SetName(name string) {
if d == nil {
return
}
d.name = name
}
type IUser interface {
insert(*User)
getUser(int) *User
}
type SqlServerUser struct {
}
func (s *SqlServerUser) insert(u *User) {
if s == nil {
return
}
fmt.Println("往SqlServer的User表中插入一条User", u)
}
func (s *SqlServerUser) getUser(id int) (u *User) {
if s == nil {
return nil
}
u = &User{id, "hclacS"}
fmt.Println("从SqlServer的User表中获取一条User", *u)
return
}
type AccessUser struct {
}
func (s *AccessUser) insert(u *User) {
if s == nil {
return
}
fmt.Println("往AccessUser的User表中插入一条User", *u)
}
func (s *AccessUser) getUser(id int) (u *User) {
if s == nil {
return nil
}
u = &User{id, "hclacA"}
fmt.Println("从AccessUser的User表中获取一条User", *u)
return
}
type IDepartment interface {
insert(*Department)
getDepartment(int) *Department
}
type SqlServerDepartment struct {
}
func (s *SqlServerDepartment) insert(d *Department) {
if s == nil {
return
}
fmt.Println("往SqlServer的Department表中插入一条Department", *d)
}
func (s *SqlServerDepartment) getDepartment(id int) (u *Department) {
if s == nil {
return nil
}
u = &Department{id, "hclacDS"}
fmt.Println("从SqlServer的Department表中获取一条Department", *u)
return
}
type AccessDepartment struct {
}
func (s *AccessDepartment) insert(u *Department) {
if s == nil {
return
}
fmt.Println("往AccessDepartment的Department表中插入一条Department", *u)
}
func (s *AccessDepartment) getDepartment(id int) (u *Department) {
if s == nil {
return nil
}
u = &Department{id, "hclacDA"}
fmt.Println("从AccessDepartment的Department表中获取一条Department", *u)
return
}
type Ifactory interface {
createUser() IUser
createDepartment() IDepartment
}
type SqlServerFactory struct {
}
func (s *SqlServerFactory) createUser() IUser {
if s == nil {
return nil
}
u := &SqlServerUser{}
return u
}
func (s *SqlServerFactory) createDepartment() IDepartment {
if s == nil {
return nil
}
u := &SqlServerDepartment{}
return u
}
type AccessFactory struct {
}
func (s *AccessFactory) createUser() IUser {
if s == nil {
return nil
}
u := &AccessUser{}
return u
}
func (s *AccessFactory) createDepartment() IDepartment {
if s == nil {
return nil
}
u := &AccessDepartment{}
return u
}
type DataAccess struct {
db string
}
func (d *DataAccess) createUser(db string) IUser {
if d == nil {
return nil
}
var u IUser
if db == "sqlserver" {
u = new(SqlServerUser)
} else if db == "access" {
u = new(AccessUser)
}
return u
}
func (d *DataAccess) createDepartment(db string) IDepartment {
if d == nil {
return nil
}
var u IDepartment
if db == "sqlserver" {
u = new(SqlServerDepartment)
} else if db == "access" {
u = new(AccessDepartment)
}
return u
}
~~~
';