lieon
lieon

Combine学习笔记

Combine的角色

  • Publisher；负责发布事件
  • Subscriber：负责订阅事件
  • Operator：负责转换事件和数据
  • Publisher发布事件经过Operator处理中转，最终由Subscriber订阅接收

Publisher

事件发布

  • Combine 中包括 Publisher 在内的一系列角色都使用协议来进行定义
public protocol Publisher {
    associatedtype Output
    associatedtype Failure : Error
    
    func receive(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input
}
  • Publisher 最主要的工作: 发布新的事件及其数据，准备好被 Subscriber 订阅。
  • Publisher 可以发布三种事件:
      1. 类型为 Output 的新值:这代表事件流中出现了新的值。
      1. 类型为 Failure 的错误:这代表事件流中发生了问题，事件流到此终止。
      1. 完成事件:表示事件流中所有的元素都已经发布结束，事件流到此终止。
  • 对于第一种事件，Publisher 会直接将新的值发布出来。后两种事件在 Combine 中 则使用Subscribers.Completion 来描述，Completion 是一个含有两个成员的 enum，其中成员类型为 .failure(Failure) 以及 .finished。

有限事件流和无限事件流

  • 最终会终结的事件流称为有限事件流，比如一个网络请求
  • 将不会发出 failure 或者 finished 的事件流 称为无限事件流，比如按钮的点击

如何创建Publisher（Publisher从哪里来）

  • Publishers.Sequence。顾名思义，Publishers.Sequence 接受一个 Sequence:它可以是一个数组，也可以是一个 Range。在被订阅时，Sequence 中的元素被逐个发 送出来:
check("Sequence") {
  Publishers.Sequence<[Int], Never>(sequence: [1, 2, 3])
}
check("Array") {
  [1, 2, 3].publisher
}
// 输出:
//----- Sequence -----
// receive subscription: ([1, 2, 3])
// request unlimited
// receive value: (1)
// receive value: (2)
// receive value: (3)
// receive finished

Subject

  • Subject 本身也是一个 Publisher:
public protocol Subject : AnyObject, Publisher {
  func send(_ value: Self.Output)
  func send(completion: Subscribers.Completion)
}
  • Combine 内置提供了两种常用的 Subject 类型,分别是和CurrentValueSubject。
  • PassthroughSubject 简单地将 send 接收到的事件转发给下游的其他 Publisher 或 Subscriber:
let publisher2 = PassthroughSubject() 
publisher2.send(1)
print("开始订阅") 
publisher2.sink(
  receiveCompletion: { complete in print(complete)
},
  receiveValue: { value in
    print(value)
  }
)

let s1 = check("Subject") { () -> PassthroughSubject in
let subject = PassthroughSubject() delay(1) {
    subject.send(1)
    delay(1) {
      subject.send(2)
      delay(1) {
        subject.send(completion: .finished)
      }
} }
return subject 
}
  • CurrentValueSubject 则会包装和持有一个值，并在 设置该值时发送事件并保留新的值。在订阅发生的瞬间，CurrentValueSubject 会把 当前保存的值发送给订阅者
let publisher3 = CurrentValueSubject(0)
print("开始订阅") 
publisher3.sink(
  receiveCompletion: { complete in print(complete)
},
  receiveValue: { value in
    print(value)
  }
)
publisher3.value = 1
publisher3.value = 2
publisher3.send(completion: .finished)
// 输出: !" 开始订阅 !"0
// 1
// 2
// finished
  • Just：订阅和值的发布其实是同步过程，它往往被 用来将某个值 “包装” 成一个 Publisher 来提供给各类 Publisher 的合并操作
  • Future: 订阅操作和值的发布是异步行为，不在同一时间发生的话，可以使用 Future。Future 提供了一种方式，可以让我们创建一个接受未来的事件的 Publisher。
  func testFuture() {
        Future<(Data, URLResponse), Error> { promise in
            self.loadPage(url: URL(string: "sdf")!) { data, response, error in
                if let data = data, let response = response {
                    promise(.success((data, response)))
                } else {
                    promise(.failure(error!))
                }
            }
        }
    }
  • 使用 Subject，相对于单次事件的网络请求，可以发布多次事件的操作在日常开发中更加常见:
 func testSubject() {
        let subject = PassthroughSubject()
        Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
            subject.send(Date())
        }
    }

Foundation 中的 Publisher

  • URLSession Publisher
func test() {
   URLSession.shared
    .dataTaskPublisher(for: URL(string: "https:!"httpbin.org/get?foo=bar")!)
   .map{data,_indata}
   .decode(type: Response.self, decoder: JSONDecoder()) .compactMap { $0.args!"foo }
}
  • Timer Publisher: Foundation 中的 Timer 类型也提供了一个方法，来创建一个按照一定间隔发送事件 的 Publisher
func test() {
    let temp = check("Timer") {
        Timer.publish(every: 1, on: .main, in: .default)
    }
}
  • Notification Publisher
extension NotificationCenter {
    public func publisher(
        for name: Notification.Name,
        object: AnyObject? = nil
    ) -> NotificationCenter.Publisher
}

  func testNotificationPublisher() -> AnyPublisher  {
      NotificationCenter.default
           .publisher(for: UIApplication.didBecomeActiveNotification, object: nil)
           .map { $0.object as! Response}
           .eraseToAnyPublisher()
  }
  • @Published: Combine 中存在 @Published 封装，用来把一个 class 的属性值转变为 Publisher。它同时提供了值的存储和对外的 Publisher (通过投影符号 $ 获取)。在被 订阅时，当前值也会被发送给订阅者，它的底层其实就是一个 CurrentValueSubject
class Wrapper {
    @Published var text: String = "hoho"
}
var wrapper = Wrapper()
check("Published") {
    wrapper.$text
}
wrapper.text = "123"
wrapper.text = "abc"

Operator

  • Operator使用上游 Publisher 所发布的数据作为输入， 以此产生的新的数据，然后自身成为新的 Publisher，并将这些新的数据作为输出，发布给下游
  • 通过一系列组合，可以得到一个响应式的 Publisher 链条: 当链条最上端的 Publisher 发布某个事件后，链条中的各个 Operator 对事件和数据进行处理。在链条的末端我们希望最终能得到可以直接驱动 UI 状态的事件和数据。这样， 终端的消费者可以直接使用这些准备好的数据，而这个消费者的角色由 Subscriber 来担任。
  • Publisher的所有操作符

常用的Operator

  • print: publisher 发送事件时，将具体事件的内容打印到控制台
public func check(_ title: String, publisher: () -> P) -> AnyCancellable {
    print("----- \(title) -----")
    defer { print("") }
    return publisher()
        .print()
        .sink(
            receiveCompletion: { _ in},
            receiveValue: { value  in  print(value) }
        )
}
  • empty: 只在被订阅的时候发布一个完成事件 (receive finished)。这个 publisher 不会输出任何的 output 值，只能用于表示某个事件已经 发生。
Empty()
      .print()
      .sink(
            receiveCompletion: { _ in},
            receiveValue: { value  in  print(value) }
        )
// 输出:
// ----- Empty -----
//receive subscription: (Empty) !" request unlimited
//receive finished
  • map: 对Publisher的 output 的元素 进行变形
check("Map") {
    // 注意是在 `Publisher` 上调用了 `map`
    [1,2,3] .publisher .map{$0*2}
}
  • reduce 对Publisher中的 output 值，按照某种规则进行合并，当序列中值耗尽时，它将发布 finished事件，才会将最终的reduce后的结果发布出来。
    reduce 
check("Reduce") {
  [1,2,3,4,5].publisher.reduce(0, +)
}
// 输出:
// ----- Reduce -----
//  receive subscription: (Once) !" request unlimited
// receive value: (15)
// receive finished
  • scan： 把运算的每一步结果，保存并发布出来
extension Sequence {
    public func scan(
        _ initial: ResultElement,
        _ nextPartialResult: (ResultElement, Element) -> ResultElement
    ) -> [ResultElement] {
        var result: [ResultElement] = []
        for x in self {
            result.append(nextPartialResult(result.last ?? initial, x))
        }
        return result
    }
}

func testScan() {
  check("Scan") {
    [1,2,3,4,5].publisher.scan(0, +)
  }
// ----- Scan -----
// receive subscription: ([1, 3, 6, 10, 15])
// request unlimited
// receive value: (1)
// receive value: (3)
// receive value: (6)
// receive value: (10)
// receive value: (15)
// receive finished
}
scan
  • compactMap: 将 map 结果中那些 nil 的元素去除掉，这个操作通常会 “压缩” 结果，让其中的元素数减少
func testCompactMap() {
  check("Compact Map") {
    ["1", "2", "3", "cat", "5"]
    .publisher
    .compactMap { Int($0) }
  }
// 输出:
//  ----- Compact Map -----
// receive subscription: ([1, 2, 3, 5])
}
  • flatMap flatMap 将外层 Publisher 发出的事件中的值传递给内层 Publisher，然后汇总内层 Publisher 给出的事件输出，作为最终变形后的结果。其核心目的是为了 "降维"
func testFlatMap() {
  check("Flat Map 1") {
    [[1, 2, 3], ["a", "b", "c"]]
    .publisher
    .flatMap {
        $0.publisher
    }
  }

  check("Flat Map 2") {
    ["A", "B", "C"]
    .publisher
    .flatMap { letter in
        [1, 2, 3]
          .publisher
          .map { "\(letter)\($0)" }
    } 
  }
// 输出:
// ----- Flat Map 2 -----
// receive subscription: (FlatMap) !" request unlimited
// receive value: (A1)
// receive value: (A2)
// receive value: (A3)
// receive value: (B1)
// receive value: (B2)
// receive value: (B3)
// receive value: (C1)
// receive value: (C2)
// receive value: (C3)
// receive finished

}
flatMap
  • removeDuplicates: 过滤掉这些重复的事件，进而避免无谓的额外开销
func test() {
    check("Remove Duplicates") {
        ["S", "Sw", "Sw", "Sw", "Swi","Swif", "Swift", "Swift", "Swif"]
            .publisher
            .removeDuplicates()
    }
    // 输出:
    // ----- Remove Duplicates -----
    // receive subscription: (["S", "Sw", "Swi", "Swif", "Swift", "Swif"]) !" request unlimited
    // receive value: (S)
    // receive value: (Sw)
    // receive value: (Swi)
    // receive value: (Swif)
    // receive value: (Swift)
    // receive value: (Swif)
    // receive finished
}

  • merge：它将两个事件流进行合并，在对应的时间完整保留两个事件流的全部事件:

  • mapError： Publisher 的 Failure 转换成 Subscriber 所需要的 Failure 类型:

check("Map Error") {
  Fail(error: .sampleError)
  .mapError { _ in MyError.myError }
 }
  • tryMap: 处理数据时发生的错误转变为标志事件流失败的结束事件
    func testTryMap() {
        check("Throw") {
            ["1", "2", "Swift", "4"].publisher
                .tryMap { s -> Int in
                    guard let value = Int(s) else {
                        throw MyError.myError
                    }
                    return value
                }
        }
        // 输出:
        // ----- Throw -----
        // receive subscription: (TryMap) !" request unlimited
        // receive value: (1)
        // receive value: (2)
        // receive error: (myError)
    }
  • replaceError: 从错误中恢复, replaceError 会将 Publisher 的 Failure 类型抹为 Never，比如使用 assign 来将 Publisher 绑定到 UI 上时所需要的 Failure 类型为Never。我们可以用 replaceError 来提供这样一个在出现错误时应该显示的默认值。
      check("Replace Error") {
            ["1", "Swift", "4"]
                .publisher
                .tryMap { s -> Int in
                    guard let value = Int(s) else {
                        throw MyError.myError
                    }
                    return value
                }
                .replaceError(with: -1)
        }
replaceError
  • catch: 上游 Publisher 发生错误时，catch 操作会使用新的 Publisher 来把原来的 Publisher 替换掉, 从实例代码中看上去输出和上面的 replaceError 没有区别，但是在 catch 的闭包中，返 回的是 Just(-1) 这个 Publisher，而不仅仅只是 Int 的 -1。
    catch 
     check("Catch with Just Error") {
            ["1", "Swift", "4"]
                .publisher
                .tryMap { s -> Int in
                    guard let value = Int(s) else {
                        throw MyError.myError
                    }
                    return value
                }
                .catch({_ in [-1, -2, -3].publisher })
            //                .catch({ _ in Just(-1) })
        }
  • Catch and Continue， 比如 如果我们将 (由 ["1", "2", "Swift", "4"] 构成的) 原 Publisher 看作是用户输入，将结 果的 Int 看作是最后输出，那么像上面那样的方式使用 replaceError 或者 catch 的 话，一旦用户输入了不能转为 Int 的非法值 (如 “Swift”)，整个结果将永远停在我们给定的默认恢复值上，接下来的任意用户输入都将被完全忽略。这往往不是我们想要的结果，一般情况下，我们会想要后续的用户输入也能继续驱动输出，这时候我们 可以靠组合一些 Operator 来完成所需的逻辑
   check("Catch and Continue") {
            ["1", "2", "Swift", "4"]
                .publisher
                .print("[ Original ]")
                .flatMap { s in
                    return Just(s)
                        .tryMap { s -> Int in
                            guard let value = Int(s) else {
                                throw MyError.myError
                            }
                            return value
                        }
                        .print("[ TryMap ]")
                        .catch { _ in
                            Just(-1)
                                .print("[ Just ]")
                        }
                        .print("[ Catch ]")
                }
        }
  • zip: 它会把两个 (或多个) Publisher 事 件序列中在同一 index 位置上的值进行合并，也就是说，Publisher1 中的第一个事 件和 Publisher2 中的第一个事件结对合并，Publisher1 中的第二个事件和 Publisher2 中的第二个事件合并，以此类推, zip 在时序语义上更接近于 “当...且...”，当 Publisher1 发布值，且 Publisher2 发布 值时，将两个值合并，作为新的事件发布出去。在实践中，zip 经常被用在合并多个 异步事件的结果，比如同时发出了多个网络请求，希望在它们全部完成的时候把结 果合并在一起
  func testZip() {
        let subject1 = PassthroughSubject()
        let subject2 = PassthroughSubject()
        
        check("testZip") {
          subject1.zip(subject2)
        }
        subject1.send(1)
        subject2.send("A")
        subject1.send(2)
        subject2.send("B")
        subject2.send("C")
        subject2.send("D")
        subject1.send(3)
        subject1.send(4)
        subject1.send(5)
    }

// 输出:
// ----- Zip -----
//  receive subscription: (Zip) !" request unlimited
// receive value: ((1, "A")) 
// receive value: ((2, "B")) 
// receive value: ((3, "C")) 
// receive value: ((4, "D"))
  • combineLatest: 它的语义接近于 “当...或...”，当 Publisher1 发布 值，或者 Publisher2 发布值时，将两个值合并，作为新的事件发布出去。在实践中，combineLatest 被用来处理多个可变状态，在其中某一个状态发生变化 时，获取这些全部状态的最新值。
 // combineLatest
    func testCombineLatest() {
        // 它的语义接近于 “当...或...”，当 Publisher1 发布 值，或者 Publisher2 发布值时，将两个值合并，作为新的事件发布出去。
        let subject1 = PassthroughSubject()
        let subject2 = PassthroughSubject()
        
        check("combineLatest") {
          subject1.combineLatest(subject2)
        }
        
        subject1.send(1)
        subject2.send("A") // 1A
        subject1.send(2) // 2A
        subject2.send("B") //2B
        subject2.send("C")
        subject2.send("D")
        subject1.send(3)
        subject1.send(4)
        subject1.send(5)
    }

类型抹消 - eraseToAnyPublisher

  • 类型转换作用，抹除了publisher在通过Operator产生的一些中间类型，直接将最后的类型作为输出
extension Publisher {
    @inlinable
    public func eraseToAnyPublisher() -> AnyPublisher {
        return .init(self)
    }

  @inlinable
    public init(_ publisher: PublisherType)
        where Output == PublisherType.Output, Failure == PublisherType.Failure
    {
        // If this has already been boxed, avoid boxing again
        if let erased = publisher as? AnyPublisher {
            box = erased.box
        } else {
            box = PublisherBox(base: publisher)
        }
    }
}


let p1 = [[1, 2, 3], [4, 5, 6]] .publisher
.flatMap { $0.publisher }
// p1 : Publishers.FlatMap<
//    Publishers.Sequence<[Int], Never>,
//     Publishers.Sequence<[[Int]], Never>
//   >

let p2=p1.map{$0*2} 
// p2 : Publishers.Map,
//       Publishers.Sequence<[[Int]], Never>
//     >,
// Int >

let p3 = p2.eraseToAnyPublisher()  
// let p3: AnyPublisher.Output, Never>, Publishers.Sequence<[[Int]], Never>>, Int>.Failure>
// p3: AnyPublisher

let p1_ = Publishers.FlatMap(
upstream: [[1, 2, 3], [4, 5, 6]].publisher, maxPublishers: .unlimited)
{
    $0.publisher
}

let p2_ = Publishers.Map(upstream: p1_) { $0 * 2 }


   public struct FlatMap: Publisher
        where Child.Failure == Upstream.Failure
    {
        public typealias Output = Child.Output

        public typealias Failure = Upstream.Failure

        public let upstream: Upstream

        public let maxPublishers: Subscribers.Demand

        public let transform: (Upstream.Output) -> Child

        public init(upstream: Upstream, maxPublishers: Subscribers.Demand,
                    transform: @escaping (Upstream.Output) -> Child) {
            self.upstream = upstream
            self.maxPublishers = maxPublishers
            self.transform = transform
        }
        public func receive(subscriber: Downstream)
            where Child.Output == Downstream.Input, Upstream.Failure == Downstream.Failure
        {
            let outer = Outer(downstream: subscriber,
                              maxPublishers: maxPublishers,
                              map: transform)
            subscriber.receive(subscription: outer)
            upstream.subscribe(outer)
        }
    }

 public struct Map: Publisher {

        public typealias Failure = Upstream.Failure

        /// The publisher from which this publisher receives elements.
        public let upstream: Upstream

        /// The closure that transforms elements from the upstream publisher.
        public let transform: (Upstream.Output) -> Output

        public init(upstream: Upstream,
                    transform: @escaping (Upstream.Output) -> Output) {
            self.upstream = upstream
            self.transform = transform
        }

        public func receive(subscriber: Downstream)
            where Output == Downstream.Input, Downstream.Failure == Upstream.Failure
        {
            upstream.subscribe(Inner(downstream: subscriber, map: transform))
        }
    }

Subcriber - 订阅和绑定


public protocol Subscriber {
    associatedtype Input
    associatedtype Failure : Error
    
    func receive(subscription: Subscription)
    func receive(_ input: Self.Input) -> Subscribers.Demand
    func receive(completion: Subscribers.Completion)
}

通过 sink 订阅 Publisher 事件

  • sink订阅Publisher事件中的value

let buttonClicked: AnyPublisher buttonClicked
.scan(0) { value, _ in value + 1 }
.map { String($0) }
.sink { print("Button pressed count: \($0)") }

通过 assign 绑定 Publisher 值

  • assign 所接 受的第一个参数的类型为 ReferenceWritableKeyPath，也就是说，只有 class 上用 var 声明的属性可以通过 assign 来直接赋值。
  • assign 的另一个 “限制” 是，上游 Publisher 的 Failure 的类型必须是 Never。如果 上游 Publisher 可能会发生错误，必须先对它进行处理，比如使用 replaceError 或者 catch 来把错误在绑定之前就 “消化” 掉。
let foo = Foo()
let buttonClicked: AnyPublisher buttonClicked
.scan(0) { value, _ in value + 1 } .map { String($0) }
.assign(to: \.bar, on: foo)
  • 问题：
  • 下面代码在combine内部的执行流程（见流程图或者源码）
  • store 方法为什么传入的参数是一个inout类型
   subject.eraseToAnyPublisher() 
      .sink { value in
            print(value)
        }
      .store(in: &bags)
  • 大致做了这些事情
    • 转换输出类型
    • 创建订阅者
    • 创建下游 Conduit （导管）
    • 设置订阅状态
    • 将AnyCancellable对象添加到输入bags中。AnyCancellable的生命周期由于外部输入Set bags决定.

Publisher 的引用共享 - share

  • 一个subject给多个下游subscribers发送元素
  • 上游Publisher只执行一次，下游被多个subscribers监听
  • 比如：一个网络请求被多个subcriber监听
  public init(upstream: Upstream) {
        self.inner = upstream.multicast(subject: .init()).autoconnect()
        self.upstream = upstream
}


    /// Provides a subject to deliver elements to multiple subscribers.
    ///
    /// Use a multicast publisher when you have multiple downstream subscribers, but you
    /// want upstream publishers to only process one `receive(_:)` call per event.
    /// This is useful when upstream publishers are doing expensive work you don’t want
    /// to duplicate, like performing network requests.
    ///
    public func multicast(
        subject: SubjectType
    ) -> Publishers.Multicast
        where Failure == SubjectType.Failure, Output == SubjectType.Output
    {
        return multicast { subject }
    }

  public func multicast(
        subject: SubjectType
    ) -> Publishers.Multicast
        where Failure == SubjectType.Failure, Output == SubjectType.Output
    {
        return multicast { subject }
    }

 public final class Multicast
        : ConnectablePublisher
        where Upstream.Failure == SubjectType.Failure,
              Upstream.Output == SubjectType.Output
    {
        private var lazySubject: SubjectType {
            lock.lock()
            if let subject = subject {
                lock.unlock()
                return subject
            }

            let subject = createSubject()
            self.subject = subject
            lock.unlock()
            return subject
        }

        public init(upstream: Upstream, createSubject: @escaping () -> SubjectType) {
            self.upstream = upstream
            self.createSubject = createSubject
        }


        public func receive(subscriber: Downstream)
            where SubjectType.Failure == Downstream.Failure,
                  SubjectType.Output == Downstream.Input
        {
            lazySubject.subscribe(Inner(parent: self, downstream: subscriber))
        }

    }


func test() {
     let dataTaskPublisher = URLSession.shared
            .dataTaskPublisher(for: URL(string: "https://httpbin.org/get?foo=bar")!)
            .share()

        let isSuccess = dataTaskPublisher.map { data, response -> Bool in
            guard let httpRes = response as? HTTPURLResponse else { return false }
            return httpRes.statusCode // 200
        }
            .replaceError(with: false)
        
        let latestText = dataTaskPublisher
            .map{ data,_ in data}
            .decode(type: Response.self, decoder: JSONDecoder()) .compactMap { $0.args!"foo
            }
            .replaceError(with: "")
}

Cancellable, AnyCancellable 和内存管理

public final class AnyCancellable: Cancellable, Hashable {

    private var _cancel: (() -> Void)?

    public init(_ cancel: @escaping () -> Void) {
        _cancel = cancel
    }

    public init(_ canceller: OtherCancellable) {
        _cancel = canceller.cancel
    }

    public func cancel() {
        _cancel?()
        _cancel = nil
    }

    public static func == (lhs: AnyCancellable, rhs: AnyCancellable) -> Bool {
        return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(self))
    }

    deinit {
        _cancel?()
    }
}

Scheduler

  • A protocol that defines when and how to execute a closure.
  • Scheduler 所要解决的就 是两个问题:在什么地方 (where)，以及在什么时候 (when) 来发布事件和执行代码。
  • Debounce
  • Delay
  • MeasureInterval
  • SubscribeOn
  • Throttle
  • Timeout
  • ImmediateScheduler
  • DispatchQueue
  • OperationQueue
  • RunLoop
  • Timer
func test() {
  URLSession.shared
    .dataTaskPublisher(for: URL(string: "https:!"example.com")!)
    .compactMap { String(data: $0.data, encoding: .utf8) }
    .receive(on: RunLoop.main)
  .sink(receiveCompletion: { _ in
    }, receiveValue: {
      textView.text = $0
  })
}
  • 在什么地方 (where): RunLoop 就是一个实现了 Scheduler 协议的类型，它知道要如何执行后续的订阅任 务
  • receive(on: RunLoop.main) 决定下游数据在主线程执行
  pub.sink {
     DispatchQueue.main.async {
     // Do something.
    }
   }

    /// Use this pattern instead:
    pub.receive(on: DispatchQueue.main).sink {
        // Do something.
   }
  • subscribe(on: RunLoop.main) 决定上游数据在主线程执行
    let ioPerformingPublisher == // Some publisher.
    let uiUpdatingSubscriber == // Some subscriber that updates the UI.
      ioPerformingPublisher
      .subscribe(on: backgroundQueue) // 决定 ioPerformingPublisher 在后台线程中运行
      .receive(on: RunLoop.main) // 决定 uiUpdatingSubscriber 在RunLoop.main运行
     .subscribe(uiUpdatingSubscriber)
  • 在什么时候 (when): 比较常见的两种操作是 delay 和 debounce。delay 简单地将所有事件按照一定事件 延后。debounce 则是设置了一个计时器，在事件第一次到来时，计时器启动。在计 时器有效期间，每次接收到新值，则将计时器时间重置。当且仅当计时窗口中没有新 的值到来时，最后一次事件的值才会被当作新的事件发送出去。

你可能感兴趣的:(Combine学习笔记)

  • Redis学习笔记 csdn_bobo_6 redis学习数据库
    认识NoSQLNoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在处理web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，出现了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，特别是大数据应用难题。NoSQL特点方便扩展（
  • CTF学习笔记——[ACTF2020 新生赛]BackupFile Obs_cure 网络安全
    一、[ACTF2020新生赛]BackupFile1.题目2.解题步骤看了一眼源码什么都没有。难道要暴力扫目录？先试试flag.php阿这还真有…但是还是什么都没有显示。再试试index.php的备份呢？备份有点东西。审计一下发现是弱类型。这段源码的大意就是输入一个key变量，如果key=str(123ffwsfwefwf24r2f32ir23jrw923rskfjwtsw54w3)，那么打印fl
  • L8打卡学习笔记 无涯学徒1998 学习笔记支持向量机
    本文为365天深度学习训练营中的学习记录博客原作者：K同学啊SVM与集成学习SVMSVM线性模型SVM非线性模型SVM常用参数集成学习随机森林导入数据查看数据信息数据分析随机森林模型预测结果结果分析个人总结SVM超平面：SVM在特征空间中寻找一个能够最大化类别间隔的超平面，称为最大间隔超平面。这个超平面就是将数据集分成不同类别的边界。支持向量：支持向量是离分隔超平面最近的样本点，它们决定了超平面的
  • P5学习笔记 无涯学徒1998 pythonpytorch
    本文为365天深度学习训练营中的学习记录博客原作者：K同学啊运动鞋品牌识别设置GPU导入数据构建CNN模型编写训练函数编写测试函数设置动态学习率等间隔动态调整自定义调整多间隔调整余弦退火正式训练结果可视化使用模型进行预测个人总结设置GPUimporttorchimporttorch.nnasnnimporttorchvision.transformsastransformsimporttorchv
  • 【学习笔记】昇思25天学习打卡(D14)CV05-SSD目标检测.ipynb UnseenMe 昇思学习笔记目标检测
    SSD目标检测模型简介SSD，全称SingleShotMultiBoxDetector，是WeiLiu在ECCV2016上提出的一种目标检测算法。使用NvidiaTitanX在VOC2007测试集上，SSD对于输入尺寸300x300的网络，达到74.3%mAP(meanAveragePrecision)以及59FPS；对于512x512的网络，达到了76.9%mAP，超越当时最强的FasterRC
  • 【gopher的java学习笔记】一文讲懂controller，service，mapper，entity是什么 ThisIsClark gopher的java学习笔记java学习笔记
    刚开始上手Java和Spring时，就被controller，service，mapper，entity这几个词搞懵了，搞不懂这些究竟代表什么，感觉使用golang开发的时候也没太接触过这些名词啊~经过两三个月的开发后，逐渐搞懂了这几个词的意义，也对为什么要这么分有了一点见解，总结了一下希望能帮到各位刚刚接触Java和Spring的同学。组件介绍Entity（实体）作用：代表数据库中的表结构，是数
  • 理解inode zhanshenyn linuxtableunixfile存储user
    inode是一个重要概念，是理解Unix/Linux文件系统和硬盘储存的基础。我觉得，理解inode，不仅有助于提高系统操作水平，还有助于体会Unix设计哲学，即如何把底层的复杂性抽象成一个简单概念，从而大大简化用户接口。下面就是我的inode学习笔记，尽量保持简单。===================================理解inode作者：阮一峰一、inode是什么？理解inode
  • 龙珠训练营机器学习task04 a_little_pig_ python
    学习笔记为阿里云天池龙珠计划机器学习训练营的学习内容，学习链接为：https://tianchi.aliyun.com/competition/entrance/231702/introduction?spm=5176.20222472.J_3678908510.8.8f5e67c2RKrT98总体思路：分别使用LightGBM，xgboost，gbdt，catboost建立多个个体学习器（加入b
  • 【贪心算法】洛谷P1106 - 删数问题 仟濹 算法学习笔记贪心算法算法c语言c++
    2025-01-22-第46篇【洛谷】贪心算法题单-【贪心算法】-【学习笔记】作者(Author):郑龙浩/仟濹(CSND账号名)目录文章目录目录P1106删数问题题目描述输入格式输出格式样例#1样例输入#1样例输出#1提示思路代码P1106删数问题题目描述键盘输入一个高精度的正整数nnn（不超过250250250位），去掉其中任意kkk个数字后剩下的数字按原左右次序将组成一个新的非负整数。编程对
  • 新能源汽车 BMS 学习笔记篇——如何选择继电器 & MOS 管作为开关 WPG大大通 其他教程笔记MOS大大通继电器
    序：继电器和MOSFET（俗称MOS管）都可以用作BMS（BatteryManagementSystem，电池管理系统）中控制电池充放电的开关，但它们在原理、结构和特性上存在一些区别，以下总结它们之间主要区别及适用场景一、继电器&MOS管的组成结构及工作原理1、继电器：由线圈、触点和机械部件组成。当ControlSwitch闭合时，触发继电器的电磁线圈产生磁场，使其吸引或释放触点（RelayCon
  • 【C++】初学者的浪漫编程指南 星霜旅人 C++c++
    少年不惧岁月长，彼方尚有荣光在。前言这是我自己学习C++的第一篇博客总结。后期我会继续把C++学习笔记开源至博客上。C++的兼容性1.C++兼容绝大多数C语言的语法，因此只需要把.c后缀文件改为.cpp即可。2.VS编译器看到是.cpp就会调用C++编译器编译。#define_CRT_SECURE_NO_WARNINGS#includeintmain(){printf("helloworld\n"
  • 【学习笔记】手把手教你使用Autoware标定SICK-2D激光雷达和相机 Masec 学习笔记Autoware标定二维雷达
    2019/06/21更新说明：很多小伙伴反应从github上下载的Autoware没有CalibrationToolkit，是作者在github的新源码和我用的版本不一样了。该教程仅针对2018年11月7日的发布版本。网上Autoware的教程不多，而且都是关于多线的威力登雷达和相机的联合标定。自己摸索使用Autoware标定SICKTIM561单线激光雷达和相机的方法，写一个详细的教程，希望可以
  • Three.js学习笔记(一) hzxwonder three.jswebglthree.js
    Three.js学习笔记(一)1.四大组建1.场景任何要显示的东西，放在场景的任何位置一个页面可以有多个场景实现方式THREE.Scene=function()2.相机浏览器中所能看到的东西，就是由相机拍摄出来。即将相机能看到的内容显示在浏览器画面上分类1.透视相机近大远小+灭点2.正投影相机远处和近处一样大，也称正交相机参数THREE.PerspectiveCamera=function(fov
  • CSS学习笔记9——定位position green_pine_ CSScss学习笔记前端html
    CSS定位可以让盒子自由的在某个盒子内移动位置或者固定屏幕中某个位置，并且可以压住其他盒子定位组成定位=定位模式+边偏移定位模式用于指定一个元素在文档中的定位方式边偏移决定了该元素的最终位置定位模式通过position属性来设置值语义static静态定位relative相对定位absolute绝对定位fixed固定定位边偏移属性：top、bottom、left、right属性示例描述toptop:
  • AirSim学习（3）AirSim的PythonAPI基本操作——环境配置与VehicleClient类 睡觉狂魔er AirSim虚幻自动驾驶python
    文章内容AirSim学习笔记汇总AirSim的PythonAPI的安装AirSim的坐标系统classVehicleClient1.成员变量2.构造函数3.连接与仿真启停resetpinggetClientVersiongetServerVersiongetMinRequiredServerVersiongetMinRequiredClientVersionenableApiControlisAp
  • BabylonJS初学习笔记 Marina-37 学习笔记
    初步接触Babylonjs，由于学习跨度会比较大，所以就做了一些笔记，在此分享出来，希望能够对那些和我一样学习的新人有所帮助。通过Babylon官网学习这个项目主要就是一些基础方法的学习，以静态HTML为主，附带一些个人笔记，持续更新。项目地址：babylon-learn-byDoc:通过babylon官方网站进行学习，创建一些交互式web文件。Babylon官网：https://www.baby
  • [JS]学习笔记2 -- JAVAScript数据类型 Jizhi_Zhang JavaScript学习笔记javascript学习笔记
    一、常量概念：使用const声明的变量称为“常量”。使用场景：当某个变量永远不会改变的时候，就可以使用const来声明，而不是let。命名规范：和变量一致注：常量不允许重新赋值，在声明的时候必须要赋值（初始化）二、数据类型1、基本数据类型1.1数字型number学习中的数字，整数、小数、正数、负数可以有很多操作：算数+：求和-：求差*：求积/：求商%：取模（取余数）--开发中经常作为某个数字是否被
  • Three.js学习笔记 癫狂de痴梦 前端javascript学习前端
    1.three.js的引入进入官网Three.js–JavaScript3DLibrary，下载文件解压文件，复制three.js-master\build\three.min.js文件在项目中，引入该文件。2.一个简单threeJs程序（1）创建场景constscene=newTHREE.Scene();（2）创建物体constgeomtry=newTHREE.BoxGeometry(1,1,1
  • 侯捷 C++ 课程学习笔记：开启 C++ 深度探索之旅 秃头小饼干 jvm开发语言c++
    在C++的学习道路上，侯捷老师的课程宛如一座明亮的灯塔，为无数学习者照亮前行的方向。经过一段时间对侯捷C++课程的深入学习，我收获颇丰，在此将自己的学习笔记和感悟分享给大家，希望能对正在学习C++或者准备踏入C++领域的朋友们有所帮助。一、课程初印象初次接触侯捷老师的课程，就被其深入浅出的讲解风格所吸引。老师不仅有着深厚的技术功底，更具备出色的教学能力，能够将复杂的C++知识以通俗易懂的方式呈现出
  • stable diffusion 模型和lora融合 Kun Li 图像视频生成大模型stablediffusion
    炜哥的AI学习笔记——SuperMerger插件学习-哔哩哔哩接下来学习的插件名字叫做SuperMerger，它的作用正如其名，可以融合大模型或者LoRA，一般来说会结合之前的插件LoRABlockWeight使用，在调整完成LoRA模型的权重后使用改插件进行重新打包。除了LoRA，Checkpoint也可以通过这个插件进行融合合并。实际上，目前市面上存在大量的Checkpoint模型都是经由合并
  • Java Web学习笔记 淘气的然酱 计算机学习笔记java学习后端
    JavaWeb后端基础第1章Maven项目1.1Maven简介Maven基于项目对象模型，通过一小段描述信息来管理项目的构建、报告和文档。Maven提供了一套标准化的项目结构、构建流程和一套依赖管理机制。Maven模型：pom.xml→项目对象模型↔依赖管理模型→仓库Maven仓库包含本地仓库、中央仓库、远程仓库（私服）。Maven项目获取jar包时，首先在本地仓库寻找是否有对应jar包，若没有则
  • Django学习笔记 mengmwng Djangodjango学习笔记
    学习视频来源：最新Python的web开发全家桶代码仓库：https://gitee.com/m_engmeng/django-learning1.创建项目Django中项目会有一些默认的文件和文件夹1.1在终端打开终端进入某个目录(项目放在哪里)输入命令——创建项目(最后一个参数是项目名)django-adminstartprojectmysite继续输入——创建app（最后一个参数是app所处
  • MyBatis-Plus 学习笔记-条件构造器（不想写sql） 咕德猫宁丶 Mybatis-plus学习mybatis学习springboot
    MyBatis-Plus提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper类允许开发者以链式调用的方式构造查询条件，无需编写繁琐的SQL语句，从而提高开发效率并减少SQL注入的风险。在MyBatis-Plus中，Wrapper类是构建查询和更新条件的核心工具。以下是主要的Wrapper类及其功能：AbstractWrapper：这是一个抽象基类，提供了所有W
  • 麦田物语学习笔记:背包物品选择高亮显示和动画 扶离_flee 麦田物语学札学习笔记
    如题,本篇文章没讲动画效果基本流程1.代码思路(1)先用点击事件的接口函数去实现,点击后反转选择状态(isSelected),以及设置激活状态(SetActive),并且还需要判断该格子是否为空,空格子是点不动的,完成后以上后,出现的问题是高亮应该是有且仅有一个格子是高亮的,而现在可以让多个都高亮(2)基于以上问题,需要遍历所有的格子,使被选中的格子变为那个唯一高亮的(3)值得注意的是,Inven
  • 麦田物语学习笔记:创建DragItem实现物品的拖拽跟随显示 扶离_flee 麦田物语学札学习笔记
    基本流程1.代码思路(1)在SlotUI中使用拖拽接口IBeginDragHandler,IDragHandler,IEndDragHandler(2)开始拖拽的时候,在屏幕上生成物体,拖拽期间物体显示为当前被拖拽的物体的图标,停止拖拽时图标消失(3)基于以上,所以我们要获得这个图标的控制,则要去InventoryUI里获得(4)在停止拖拽的时候检测该位置所对应的GameObject,值得注意的是
  • 二进制 GCD 学习笔记 PandaLYL 数学学习笔记
    前言欧几里得算法可以在log的时间复杂度内求出个数的GCD，但是这还是太慢了。在一些题目中，欧几里得算法就会TLE。欧几里得算法理论：gcd⁡(a,b)=gcd⁡(b,a mod b)\gcd(a,b)=\gcd(b,a\bmodb)gcd(a,b)=gcd(b,amodb)二进制GCD更相减损术已知两个数aaa,bbb,求gcd⁡(a,b)\gcd(a,b)gcd(a,b)。设a≥ba\geba
  • 保研考研机试攻略：第一章——从零开始 杜若南星 保研考研机试攻略考研数据结构算法笔记经验分享c++c语言
    欢迎大家来到保研考研机试攻略专栏，该专栏将更新我对N诺平台的计算机考研机试攻略——高分篇、满分篇教程的学习笔记和心得，N诺是唯一一个纯粹为计算机考研而准备的学习平台，学完这些教程的内容，相信我们都会拿到满意的机试高分，如果你也对机试考试的准备感到迷茫，来和我一起学习吧~有任何问题欢迎评论区留言或私信我，让我们一起拿捏机试，顺利上岸！！！目录1.1输入输出技巧(1)基本类型输入输出(2)gets、g
  • MYSQL学习笔记(五)：单行函数(字符串、数学、日期时间、条件判断、信息、加密、进制转换函数)讲解 羊小猪~~ MYSQLmysql学习笔记sql数据库考研后端
    前言：学习和使用数据库可以说是程序员必须具备能力，这里将更新关于MYSQL的使用讲解，大概应该会更新30篇+，涵盖入门、进阶、高级(一些原理分析);这一篇是讲解单行函数，当然mysql函数很多哈，只有多用才能记得住；这些函数，如果不用，记得再牢都会忘记(我是这样的)，但是可以先看一下，动手打一下，会现用现查即可，而且现在AI这么发达不是么；虽然MYSQL命令很多，但是自己去多敲一点，到后面忘记了，
  • Spring Cloud入门-汇总篇(Hoxton版本) 2401_84049200 程序员springcloud面试spring
    《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！|9|SpringCloud入门-Bus消息总线(Hoxton版本)|https://blog.csdn.net/ThinkWon/article/details/103753372||10|SpringCloud入门-Sleuth服务链路跟踪(Hoxton版本)|https://blog.csdn
  • python中strip()和split()的使用方法（学习笔记） 木子_李轩 笔记
    1.strip()：用于移除字符串头、尾指定的字符(默认空格)，不能删除中间部分的字符。#未使用strip()path=r"C:\Users\67539\Desktop\22\11.txt"f=open(path,"r")forlineinf:#按行读取print(line)f.close()#结果cat22airplane23dog58mug86#########################
  • 矩阵求逆（JAVA）利用伴随矩阵 qiuwanchi 利用伴随矩阵求逆矩阵
    package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(利用伴随矩阵) * @author 邱万迟
  • 单例（Singleton）模式 aoyouzi 单例模式Singleton
    3.1           概述 如果要保证系统里一个类最多只能存在一个实例时，我们就需要单例模式。这种情况在我们应用中经常碰到，例如缓存池，数据库连接池，线程池，一些应用服务实例等。在多线程环境中，为了保证实例的唯一性其实并不简单，这章将和读者一起探讨如何实现单例模式。 3.2
  • [开源与自主研发]就算可以轻易获得外部技术支持,自己也必须研发 comsci 开源
          现在国内有大量的信息技术产品，都是通过盗版，免费下载，开源，附送等方式从国外的开发者那里获得的。。。。。。        虽然这种情况带来了国内信息产业的短暂繁荣，也促进了电子商务和互联网产业的快速发展，但是实际上，我们应该清醒的看到，这些产业的核心力量是被国外的
  • 页面有两个frame,怎样点击一个的链接改变另一个的内容 Array_06 UIXHTML
    <a src="地址"  targets="这里写你要操作的Frame的名字" />搜索 然后你点击连接以后你的新页面就会显示在你设置的Frame名字的框那里 targerts="",就是你要填写目标的显示页面位置 ===================== 例如： <frame src=&
  • Struts2实现单个/多个文件上传和下载 oloz 文件上传struts
    struts2单文件上传：     步骤01:jsp页面 <!--在进行文件上传时，表单提交方式一定要是post的方式，因为文件上传时二进制文件可能会很大，还有就是enctype属性，这个属性一定要写成multipart/form-data，不然就会以二进制文本上传到服务器端--> 　　<form action="fileUplo
  • 推荐10个在线logo设计网站 362217990 logo
    在线设计Logo网站。 1、http://flickr.nosv.org（这个太简单） 2、http://www.logomaker.com/?source=1.5770.1 3、http://www.simwebsol.com/ImageTool 4、http://www.logogenerator.com/logo.php?nal=1&tpl_catlist[]=2 5、ht
  • jsp上传文件 香水浓 jspfileupload
    1. jsp上传 Notice： 1. form表单 method 属性必须设置为 POST 方法 ，不能使用 GET 方法 2. form表单 enctype 属性需要设置为 multipart/form-data 3. form表单 action 属性需要设置为提交到后台处理文件上传的jsp文件地址或者servlet地址。例如 uploadFile.jsp 程序文件用来处理上传的文
  • 我的架构经验系列文章 - 前端架构 agevs JavaScriptWeb框架UIjQuer
    框架层面：近几年前端发展很快，前端之所以叫前端因为前端是已经可以独立成为一种职业了，js也不再是十年前的玩具了，以前富客户端RIA的应用可能会用flash/flex或是silverlight，现在可以使用js来完成大部分的功能，因此js作为一门前端的支撑语言也不仅仅是进行的简单的编码，越来越多框架性的东西出现了。越来越多的开发模式转变为后端只是吐json的数据源，而前端做所有UI的事情。MVCMV
  • android ksoap2 中把XML(DataSet) 当做参数传递 aijuans android
    我的android app中需要发送webservice ，于是我使用了 ksop2 进行发送，在测试过程中不是很顺利,不能正常工作.我的web service 请求格式如下     [html]  view plain copy   <Envelope xmlns="http://schemas.
  • 使用Spring进行统一日志管理 + 统一异常管理 baalwolf spring
    统一日志和异常管理配置好后，SSH项目中，代码以往散落的log.info() 和 try..catch..finally 再也不见踪影！ 统一日志异常实现类： [java]  view plain copy   package com.pilelot.web.util;      impor
  • Android SDK 国内镜像 BigBird2012 android sdk
    一、镜像地址： 1、东软信息学院的 Android SDK 镜像，比配置代理下载快多了。 配置地址， http://mirrors.neusoft.edu.cn/configurations.we#android 2、北京化工大学的： IPV4:ubuntu.buct.edu.cn  IPV4:ubuntu.buct.cn IPV6:ubuntu.buct6.edu.cn
  • HTML无害化和Sanitize模块 bijian1013 JavaScriptAngularJSLinkySanitize
    一.ng-bind-html、ng-bind-html-unsafe         AngularJS非常注重安全方面的问题，它会尽一切可能把大多数攻击手段最小化。其中一个攻击手段是向你的web页面里注入不安全的HTML，然后利用它触发跨站攻击或者注入攻击。         考虑这样一个例子，假设我们有一个变量存
  • [Maven学习笔记二]Maven命令 bit1129 maven
    mvn compile compile编译命令将src/main/java和src/main/resources中的代码和配置文件编译到target/classes中，不会对src/test/java中的测试类进行编译 MVN编译使用 maven-resources-plugin:2.6:resources maven-compiler-plugin:2.5.1:compile &nbs
  • 【Java命令二】jhat bit1129 Java命令
    jhat用于分析使用jmap dump的文件，，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言。 jhat默认开启监听端口7000的HTTP服务，jhat是Java Heap Analysis Tool的缩写 1. 用法： [hadoop@hadoop bin]$ jhat -help Usage: jhat [-stack <bool&g
  • JBoss 5.1.0 GA:Error installing to Instantiated: name=AttachmentStore state=Desc ronin47
    进到类似目录 server/default/conf/bootstrap，打开文件 profile.xml找到： Xml代码<bean    name="AttachmentStore"  class="org.jboss.system.server.profileservice.repository.AbstractAtta
  • 写给初学者的6条网页设计安全配色指南 brotherlamp UIui自学ui视频ui教程ui资料
    网页设计中最基本的原则之一是，不管你花多长时间创造一个华丽的设计，其最终的角色都是这场秀中真正的明星——内容的衬托     我仍然清楚地记得我最早的一次美术课，那时我还是一个小小的、对凡事都充满渴望的孩子，我摆放出一大堆漂亮的彩色颜料。我仍然记得当我第一次看到原色与另一种颜色混合变成第二种颜色时的那种兴奋，并且我想，既然两种颜色能创造出一种全新的美丽色彩，那所有颜色
  • 有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。写一个函数实现。复杂度是什么。 bylijinnan java算法面试
    import java.util.Random; import java.util.Set; import java.util.TreeSet; /** * http://weibo.com/1915548291/z7HtOF4sx * #面试题#有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。 * 写一个函数实现。复杂度是什么
  • struts2获得request、session、application方式 chiangfai application
    1、与Servlet API解耦的访问方式。 a.Struts2对HttpServletRequest、HttpSession、ServletContext进行了封装，构造了三个Map对象来替代这三种对象要获取这三个Map对象，使用ActionContext类。 ----->   package pro.action; import java.util.Map; imp
  • 改变python的默认语言设置 chenchao051 python
    import sys sys.getdefaultencoding()  可以测试出默认语言，要改变的话，需要在python lib的site-packages文件夹下新建： sitecustomize.py， 这个文件比较特殊，会在python启动时来加载，所以就可以在里面写上： import sys sys.setdefaultencoding('utf-8') &n
  • mysql导入数据load data infile用法 daizj mysql导入数据
    我们常常导入数据！mysql有一个高效导入方法，那就是load data infile 下面来看案例说明 基本语法： load data  [low_priority] [local] infile 'file_name txt' [replace | ignore] into table tbl_name [fields [terminated by't'] [OPTI
  • phpexcel导入excel表到数据库简单入门示例 dcj3sjt126com PHPExcel
    跟导出相对应的，同一个数据表，也是将phpexcel类放在class目录下，将Excel表格中的内容读取出来放到数据库中 <?php error_reporting(E_ALL); set_time_limit(0); ?> <html> <head> <meta http-equiv="Content-Type"
  • 22岁到72岁的男人对女人的要求 dcj3sjt126com
    22岁男人对女人的要求是：一，美丽，二，性感，三，有份具品味的职业，四，极有耐性，善解人意，五，该聪明的时候聪明，六，作小鸟依人状时尽量自然，七，怎样穿都好看，八，懂得适当地撒娇，九，虽作惊喜反应，但看起来自然，十，上了床就是个无条件荡妇。 32岁的男人对女人的要求，略作修定，是：一，入得厨房，进得睡房，二，不必服侍皇太后，三，不介意浪漫蜡烛配盒饭，四，听多过说，五，不再傻笑，六，懂得独
  • Spring和HIbernate对DDM设计的支持 e200702084 DAO设计模式springHibernate领域模型
    A：数据访问对象     DAO和资源库在领域驱动设计中都很重要。DAO是关系型数据库和应用之间的契约。它封装了Web应用中的数据库CRUD操作细节。另一方面，资源库是一个独立的抽象，它与DAO进行交互，并提供到领域模型的“业务接口”。    资源库使用领域的通用语言，处理所有必要的DAO，并使用领域理解的语言提供对领域模型的数据访问服务。
  • NoSql 数据库的特性比较 geeksun NoSQL
    Redis 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。目前由VMware主持开发工作。   1. 数据模型 作为Key-value型数据库，Redis也提供了键（Key）和值（Value）的映射关系。除了常规的数值或字符串，Redis的键值还可以是以下形式之一： Lists （列表） Sets
  • 使用 Nginx Upload Module 实现上传文件功能 hongtoushizi nginx
    转载自： http://www.tuicool.com/wx/aUrAzm   普通网站在实现文件上传功能的时候，一般是使用Python，Java等后端程序实现，比较麻烦。Nginx有一个Upload模块，可以非常简单的实现文件上传功能。此模块的原理是先把用户上传的文件保存到临时文件，然后在交由后台页面处理，并且把文件的原名，上传后的名称，文件类型，文件大小set到页面。下
  • spring-boot-web-ui及thymeleaf基本使用 jishiweili springthymeleaf
    视图控制层代码demo如下：   @Controller @RequestMapping("/") public class MessageController { private final MessageRepository messageRepository; @Autowired public MessageController(Mes
  • 数据源架构模式之活动记录 home198979 PHP架构活动记录数据映射
    hello!架构 一、概念 活动记录（Active Record）：一个对象，它包装数据库表或视图中某一行，封装数据库访问，并在这些数据上增加了领域逻辑。 对象既有数据又有行为。活动记录使用直截了当的方法，把数据访问逻辑置于领域对象中。   二、实现简单活动记录 活动记录在php许多框架中都有应用，如cakephp。 <?php /** * 行数据入口类 *
  • Linux Shell脚本之自动修改IP pda158 linuxcentosDebian脚本
    作为一名 Linux SA，日常运维中很多地方都会用到脚本，而服务器的ip一般采用静态ip或者MAC绑定，当然后者比较操作起来相对繁琐，而前者我们可以设置主机名、ip信息、网关等配置。修改成特定的主机名在维护和管理方面也比较方便。如下脚本用途为：修改ip和主机名等相关信息，可以根据实际需求修改，举一反三！ #!/bin/sh #auto Change ip netmask ga
  • 开发环境搭建 独浮云 eclipsejdktomcat
           最近在开发过程中，经常出现MyEclipse内存溢出等错误，需要重启的情况，好麻烦。对于一般的JAVA+TOMCAT项目开发，其实没有必要使用重量级的MyEclipse，使用eclipse就足够了。尤其是开发机器硬件配置一般的人。         &n
  • 操作日期和时间的工具类 vipbooks 工具类
       大家好啊，好久没有来这里发文章了，今天来逛逛，分享一篇刚写不久的操作日期和时间的工具类，希望对大家有所帮助。 /* * @(#)DataFormatUtils.java 2010-10-10 * * Copyright 2010 BianJing,All rights reserved. */ package test; impor
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他