代理模式定义
为其他对象那个提供一种，控制对这个对象的访问
代理模式角色划分
角色一：代理对象
两个特点
特点一：持有目标对象引用
特点二：实现目标接口（可选）
角色二：目标接口
角色三：具体目标对象
种类（变种）：动态代理（Java语言）、静态代理
3、代理模式-原理案例？
2017年9月13日，苹果发布了iPhoneX，行货比较贵，港货比便宜1000，我需要别人（朋友）去帮我代购。
代理对象：我们的朋友->Proxy
//
// Proxy.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import UIKit
//代理对象
//两个特点
//特点一：持有目标对象引用
//特点二：实现目标接口（可选）
class Proxy: PersonProtocol {
private var person:PersonProtocol
init(person:PersonProtocol) {
self.person = person
}
func buyProduct() {
//统计
self.person.buyProduct()
}
func payProduct() {
self.person.payProduct()
}
}
目标接口：我们想法，我们具体操作，一个业务场景->IPerson
//
// IPerson.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import Foundation
//目标接口：我们想法，我们具体操作，一个业务场景->PersonProtocol
protocol PersonProtocol {
//下单(选购)
func buyProduct()
//付款(支付)
func payProduct()
}
具体目标：我->NSLogPerson
//
// NSLogPerson.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import UIKit
//具体目标：我->NSLogPerson
class NSLogPerson: PersonProtocol {
func buyProduct() {
print("选购iPhoneX")
}
func payProduct() {
print("正在支付...")
}
}
代理模式-加强理解？
场景：服务器开发，数据库表子段非常多，一张表80多个子段？
查询时候并不需要那么多子段，只需要20个足以，其他子段用到了我再去加载（查询）
业务场景，如何设计？->代理模式（不同场景不同代理对象，为了保证对原始业务以及模块不受影响，通常情况下选择代理）？
模拟：订单数据？
案例二：代理模式实现优化？
角色一：目标接口->OrderProtocol
//
// OrderProtocol.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import Foundation
//角色一：目标接口->OrderProtocol
protocol OrderProtocol {
func getOrderId() -> String
func setOrderId(orderId:String)
func getOrderName() -> String
func setOrderName(orderName:String)
func getOrderPrice() -> String
func setOrderPrice(orderPrice:String)
func getOrderUserName() -> String?
func setOrderUserName(orderUserName:String?)
}
角色二：目标对象->OrderBean
//
// OrderBean3.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import UIKit
//角色二：目标对象->OrderBean(模型)
//没毛病（保证整体结构OK的）
class OrderBean3: OrderProtocol {
var orderId:String
var orderName:String
var orderPrice:String
var orderUserName:String?
init(orderId:String, orderName:String, orderPrice:String, orderUserName:String?) {
self.orderId = orderId
self.orderName = orderName
self.orderPrice = orderPrice
self.orderUserName = orderUserName
}
func getOrderId() -> String {
return self.orderId
}
func setOrderId(orderId:String){
self.orderId = orderId
}
func getOrderName() -> String{
return self.orderName
}
func setOrderName(orderName:String){
self.orderName = orderName
}
func getOrderPrice() -> String {
return self.orderPrice
}
func setOrderPrice(orderPrice:String){
self.orderPrice = orderPrice
}
func getOrderUserName() -> String? {
return self.orderUserName
}
func setOrderUserName(orderUserName:String?){
self.orderUserName = orderUserName
}
//业务逻辑
}
角色三：代理对象->OrderBeanProxy
//
// OrderBeanProxy.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import UIKit
//角色三：代理对象->OrderBeanProxy（保护代理->保护原有的对象）
//两个特点
//特点一：持有目标对象引用
//特点二：实现目标接口（可选）
class OrderBeanProxy: OrderProtocol {
//order->实际上就是OrderBean3引用
private var order:OrderProtocol
init(order:OrderProtocol) {
self.order = order
}
func getOrderId() -> String {
return self.order.getOrderId()
}
func setOrderId(orderId:String){
self.order.setOrderId(orderId: orderId)
}
func getOrderName() -> String{
return self.order.getOrderName()
}
func setOrderName(orderName:String){
self.order.setOrderName(orderName: orderName)
}
func getOrderPrice() -> String {
return self.order.getOrderPrice()
}
func setOrderPrice(orderPrice:String){
self.order.setOrderPrice(orderPrice: orderPrice)
}
func getOrderUserName() -> String? {
return self.loadOrderUserName()
}
func setOrderUserName(orderUserName:String?) {
self.order.setOrderUserName(orderUserName: orderUserName)
}
//扩展业务方法
private func loadOrderUserName() -> String? {
if self.order.getOrderUserName() == nil {
//查询
let service = OrderService3.shared
//准备SQL
let select = service.orders.select(service.orderUserName).where(service.orderId == self.order.getOrderId())
//执行SQL
for row in try! service.db.prepare(select){
//根据子段获取对应的值
return row[service.orderUserName]
}
}
return self.order.getOrderUserName()
}
}
//
// OrderService.swift
// Dream_20180727_Delegate
//
// Created by Dream on 2018/7/27.
// Copyright © 2018年 Tz. All rights reserved.
//
import UIKit
class OrderService3 {
private var utils:DBUtils
var db:Connection
var orders:Table
var orderId:Expression<String>
var orderName:Expression<String>
var orderPrice:Expression<String>
var orderUserName:Expression<String>
//单利对象
private static var _shared = OrderService3()
static var shared:OrderService3{
return _shared
}
private init() {
self.utils = DBUtils()
self.db = utils.getConnection()
self.orders = Table("orders")
self.orderId = Expression<String>("orderId")
self.orderName = Expression<String>("orderName")
self.orderPrice = Expression<String>("orderPrice")
self.orderUserName = Expression<String>("orderUserName")
try! self.db.run(self.orders.create { t in
t.column(self.orderId)
t.column(self.orderName)
t.column(self.orderPrice)
t.column(self.orderUserName)
})
//自定义运算符(后面学习的)->框架学了，功力大增1-2倍
let data1 = self.orders.insert(self.orderId <- "1", self.orderName <- "NBA", self.orderPrice <- "100", self.orderUserName <- "Hello")
//保存数据
try! self.db.run(data1)
let data2 = self.orders.insert(self.orderId <- "2", self.orderName <- "NBA", self.orderPrice <- "100", self.orderUserName <- "Hello")
try! self.db.run(data2)
let data3 = self.orders.insert(self.orderId <- "3", self.orderName <- "NBA", self.orderPrice <- "100", self.orderUserName <- "Hello")
try! self.db.run(data3)
}
func getOrderList() -> Array<OrderProtocol> {
var array = Array<OrderProtocol>()
//查询数据
for order in try! self.db.prepare(self.orders.select(orderId, orderName, orderPrice)) {
print("orderId: \(order[orderId])")
print("orderName: \(order[orderName])")
print("orderPrice: \(order[orderPrice])")
let orderBean = OrderBean3(orderId: order[orderId], orderName: order[orderName], orderPrice: order[orderPrice], orderUserName: nil)
//父类引用指向子类实例对象
let proxy = OrderBeanProxy(order: orderBean)
array.append(proxy)
}
return array
}
}
调用
let service = OrderService3.shared
//案例二我们使用的是具体对象->直接使用OrderBean
let array = service.getOrderList()
for order in array {
print("orderId: \(order.getOrderId())")
print("orderName: \(order.getOrderName())")
print("orderPrice: \(order.getOrderPrice())")
}
print("orderId: \(array[0].getOrderUserName())")
10个变种->静态代理（场景：保护代理（设计访问权限）、虚代理）
动态代理…
对比一下在开发中，你用代理，分析角色，养成习惯
网友评论