同分异构脑
同分异构脑

2021-01-27

Combine之Publishers

[图片上传中...(image-a4764a-1611739910254-2)]

Publishers处于pipline的最上游，它的主要作用是发送数据，本文将介绍Combine中的Publishers。

[TOC]

Just

[图片上传中...(image-6c3ea0-1611739910254-1)]

Just可以算是最简单的publisher了，它发送数据的方式相当于透传数据，最常用的场景是配合flatMap:

class JustViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    struct Student: Decodable {
        let name: String
    }

    let json = """
    [{
    "name": "小明"
    },
    {
    "name": "小红"
    },
    {
    "name": "李雷"
    }]
    """

    init() {
        let publisher = PassthroughSubject()

        cancellable = publisher
            .flatMap { value in
                Just(value.data(using: .utf8)!)
                    .decode(type: [Student].self, decoder: JSONDecoder())
                    .catch { _ in
                        Just([Student(name: "无名氏")])
                    }
            }
            .sink(receiveCompletion: { _ in
                print("结束了")
            }, receiveValue: { someValue in
                print(someValue)
            })

        publisher.send(json)
    }
}
复制代码

输出如下：

[MCMarbleDiagramSwiftUI.JustViewObservableObject.Student(name: "小明"), 
 MCMarbleDiagramSwiftUI.JustViewObservableObject.Student(name: "小红"), 
 MCMarbleDiagramSwiftUI.JustViewObservableObject.Student(name: "李雷")]
复制代码

因为flatMap闭包要求的返回值必须是一个publisher，所以在上边的代码中，使用Just比较合适，它把json数据映射成模型数组。

在上边的catch中也用到了Just，目的是当发生错误时，返回一个默认的值，值得注意的是，catch同样要求返回一个publsiher。

Future

final public class Future : Publisher where Failure : Error {

    /// A type that represents a closure to invoke in the future, when an element or error is available.
    ///
    /// The promise closure receives one parameter: a `Result` that contains either a single element published by a ``Future``, or an error.
    public typealias Promise = (Result) -> Void

    /// Creates a publisher that invokes a promise closure when the publisher emits an element.
    ///
    /// - Parameter attemptToFulfill: A ``Future/Promise`` that the publisher invokes when the publisher emits an element or terminates with an error.
    public init(_ attemptToFulfill: @escaping (@escaping Future.Promise) -> Void)

    /// Attaches the specified subscriber to this publisher.
    ///
    /// Implementations of ``Publisher`` must implement this method.
    ///
    /// The provided implementation of ``Publisher/subscribe(_:)-4u8kn``calls this method.
    ///
    /// - Parameter subscriber: The subscriber to attach to this ``Publisher``, after which it can receive values.
    final public func receive(subscriber: S) where Output == S.Input, Failure == S.Failure, S : Subscriber
}
复制代码

Future是一个专门处理异步函数的publisher，通过分析上边的代码，我们发现，它使用一个闭包来初始化，该闭包的返回值是一个Result类型，也就是说，在闭包中，我们处理异步过程，异步处理完成后，需要返回这个Result类型。

我们使用一个实例来看一下：

class FutureViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    init() {
        cancellable = Future { promise in
            /// 模拟异步过程
            DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
                return promise(.success(true))
            }
        }
        .sink(receiveCompletion: {
            print($0)
        }, receiveValue: {
            print($0)
        })
    }
}
复制代码

在上边的代码中，使用DispatchQueue.main.asyncAfter模拟了一个异步的过程，本质上，这个异步过程可以是任何异步的过程，比如平时开发中的网络请求，或者某些系统的api等等。

使用Future把现有的异步过程加入pipline中，是一个不错的实践，但需要注意一点，Future会在创建后立刻被调用，而不是等待收到订阅者的请求才调用。要验证这个问题，我们可以修改一下代码：

cancellable = Future { promise in
    print("diaoyuong")
    /// 模拟异步过程
    DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
        return promise(.success(true))
    }
}
.print()
.sink(receiveCompletion: {
    print($0)
}, receiveValue: {
    print($0)
})
复制代码

只需要在闭包中增加一个打印即可，输出如下：

diaoyuong
receive subscription: (Future)
request unlimited
receive value: (true)
true
receive finished
finished
复制代码

可以看出，闭包确实在收到请求之前就已经调用了，要解决这个问题，需要在Future外边包装一个Deferred：

cancellable = Deferred {
    return Future { promise in
        /// 模拟异步过程
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            return promise(.success(true))
        }
    }
}
.sink(receiveCompletion: {
    print($0)
}, receiveValue: {
    print($0)
})
复制代码

Empty

/// A publisher that never publishes any values, and optionally finishes immediately.
///
/// You can create a ”Never” publisher — one which never sends values and never finishes or fails — with the initializer `Empty(completeImmediately: false)`.
@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
public struct Empty : Publisher, Equatable where Failure : Error {

    /// Creates an empty publisher.
    ///
    /// - Parameter completeImmediately: A Boolean value that indicates whether the publisher should immediately finish.
    public init(completeImmediately: Bool = true)

    /// Creates an empty publisher with the given completion behavior and output and failure types.
    ///
    /// Use this initializer to connect the empty publisher to subscribers or other publishers that have specific output and failure types.
    ///
    /// - Parameters:
    ///   - completeImmediately: A Boolean value that indicates whether the publisher should immediately finish.
    ///   - outputType: The output type exposed by this publisher.
    ///   - failureType: The failure type exposed by this publisher.
    public init(completeImmediately: Bool = true, outputType: Output.Type, failureType: Failure.Type)

    /// A Boolean value that indicates whether the publisher immediately sends a completion.
    ///
    /// If `true`, the publisher finishes immediately after sending a subscription to the subscriber. If `false`, it never completes.
    public let completeImmediately: Bool
}

复制代码

Empty不发送任何数据，并且可以选择是否立刻终止pipline，默认情况下，当创建了该publisher后，它就会立刻终止piline。

我们可以利用这个特性，当监听到错误后，立刻终止pipline。

class EmptyPublisherViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    init() {
        enum MyError: Error {
            case custom
        }

        let publisher = PassthroughSubject()

        cancellable = publisher
            .catch { _ in
                Empty()
            }
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: {
                print($0)
            })

        publisher.send(1)
        publisher.send(completion: Subscribers.Completion.failure(MyError.custom))
    }
}
复制代码

上边的代码使用catch监听错误，一旦错误发生，就发送一个Emptypublisher，利用它立刻结束pipline的特性来终止pipline,它和.replaceError(with: 0)不同的地方在于后者不会终止pipline，会把错误替换成默认的值。

Fail

class FailViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    init() {
        enum MyError: Error {
            case custom
        }

        cancellable = Fail(error: MyError.custom)
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: {
                print($0)
            })

    }
}
复制代码

Fail和Empty都能立刻终止pipline，但Fail使用的场景并不多，这里就不做更多介绍了。

Publishers.Sequence

class SequenceViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    init() {
        let list: Array = [1, 2, 3]
        let set: Set = ["1", "2", "3"]
        let dict: Dictionary = ["name": "张三", "age": "20"]
        let str: String = "你好吗"

        cancellable = list.publisher
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: {
                print($0)
            })
    }
}
复制代码

Publishers.Sequence解决了像这种集合数据类型的数据流问题，凡是实现了Sequence协议的对象，都可以调用.publisher来自动创建一个publisher，然后就可以使用Combine中的所有功能。

在真实开发中，下边四种类型是最常用的：

  • Array
  • Set
  • Dictionay
  • String

前三个没啥好说的，我们看看String类型的例子：

cancellable = "你好吗".publisher
    .sink(receiveCompletion: {
        print($0)
    }, receiveValue: {
        print($0)
    })
复制代码

打印结果：

你
好
吗
finished
复制代码

有意思吧？字符串本质上就是字符的集合，使用上边的代码，轻松实现字符传输。

Record

/// A publisher that allows for recording a series of inputs and a completion, for later playback to each subscriber.
@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
public struct Record : Publisher where Failure : Error {
    /// Creates a publisher to interactively record a series of outputs and a completion.
    ///
    /// - Parameter record: A recording instance that can be retrieved after completion to create new record publishers to replay the recording.
    public init(record: (inout Record.Recording) -> Void)

    /// Creates a record publisher from an existing recording.
    ///
    /// - Parameter recording: A previously-recorded recording of published elements and a completion.
    public init(recording: Record.Recording)

    /// Creates a record publisher to publish the provided elements, followed by the provided completion value.
    ///
    /// - Parameters:
    ///   - output: An array of output elements to publish.
    ///   - completion: The completion value with which to end publishing.
    public init(output: [Output], completion: Subscribers.Completion)
}
复制代码

Record其实是一个非常强大且有用的publisher，强大在于它可以编码和解码，就像它的名字一样，可以被保存，解析，传递。核心思想是先把数据保存起来，当收到订阅后再发送数据。

从上边的代码可以看出，他有3个初始化方法：

  1. 使用record: (inout Record.Recording) -> Void闭包初始化
let recordPublisher = Record { recording in
    recording.receive("你")
    recording.receive("好")
    recording.receive("吗")
    recording.receive(completion: Subscribers.Completion.finished)
}
复制代码
  1. 使用recording: Record.Recording初始化，也就是传入一个Recording类型的实例
var recording = Record.Recording()
recording.receive("你")
recording.receive("好")
recording.receive("吗")
recording.receive(completion: Subscribers.Completion.finished)
let recordPublisher = Record(recording: recording)
复制代码
  1. 使用output: [Output], completion: Subscribers.Completion参数初始化
let recordPublisher = Record(output: ["你", "好", "吗"], completion: Subscribers.Completion.finished)
复制代码

上边这3种初始化方法的效果都是一样的，我个人更倾向于第1种，感觉它的可读性更好一点。初始化成功后，它就跟Publishers.Sequence很像了

 cancellable = recordPublisher
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: {
                print($0)
            })
复制代码

打印结果：

你
好
吗
finished
复制代码

重点来了，上边说过，它是支持编解码的，什么意思呢？ 就是我们可以把事先设定好的publisher模型保存起来，比如以JSON保存，在任何地方都可以从JSON解析成Record。

编码的例子：

let jsonEncoder = JSONEncoder()
let jsonEncoded = try? jsonEncoder.encode(recordPublisher)
if let jsonData = jsonEncoded {
    let jsonStr = String(data: jsonData, encoding: .utf8)
    print(jsonStr ?? "编码错误")
}
复制代码

{"recording":{"completion":{"success":true},"output":["你","好","吗"]}}
复制代码

解码的例子：

let jsonDecoder = JSONDecoder()
let jsonDecoded = try? jsonDecoder.decode(Record.self, from: jsonEncoded!)
if let record = jsonDecoded {
    print(record)
}
复制代码

Record(recording: Combine.Record.Recording(state: Combine.Record.Recording.State.complete, output: ["你", "好", "吗"], completion: Combine.Subscribers.Completion.finished))
复制代码

Deferred

/// A publisher that awaits subscription before running the supplied closure to create a publisher for the new subscriber.
@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
public struct Deferred : Publisher where DeferredPublisher : Publisher {
reatePublisher: () -> DeferredPublisher

    /// Creates a deferred publisher.
    ///
    /// - Parameter createPublisher: The closure to execute when calling `subscribe(_:)`.
    public init(createPublisher: @escaping () -> DeferredPublisher)
}
复制代码

简而言之，Deferred的核心思想就是当收到订阅后才创建publisher，从上边的代码中，可以看出，它创建publisher是通过初始化函数的一个闭包参数：

cancellable = Deferred {
    return Future { promise in
        /// 模拟异步过程
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            return promise(.success(true))
        }
    }
}
.sink(receiveCompletion: {
    print($0)
}, receiveValue: {
    print($0)
})
复制代码

Deferred和Future是黄金搭档，Future不管有没有订阅者都会立刻执行，配合Deferred就完美实现了把任何异步问题添加到pipline中。

还有一点，对于比较耗费性能的publisher，也可以使用Deferred包装，只有当收到订阅后才会初始化。

MakeConnectable

class MakeConnectableViewObservableObject: ObservableObject {
    var cancellable1: AnyCancellable?
    var cancellable2: AnyCancellable?

    var cancellable: Cancellable?

    init() {
        let publisher = Just("Hello, world")
            .share()
            .makeConnectable()

        cancellable1 = publisher
            .sink(receiveCompletion: {
                print("Stream 1 received: \($0)")
            }, receiveValue: {
                print("Stream 1 received: \($0)")
            })

        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.cancellable2 = publisher
                .sink(receiveCompletion: {
                    print("Stream 2 received: \($0)")
                }, receiveValue: {
                    print("Stream 2 received: \($0)")
                })
        }

        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            self.cancellable = publisher.connect()
        }
    }
}
复制代码

按照publisher正常的生命周期，一旦收到订阅就会立刻建立连接，而在某些场景下，我们需要等待符合某个条件后再建立连接。上边的代码就是一个例子，由于Just调用了.share()，所以我们希望当所有的订阅都处理完成后再建立连接，这个时候，让Just变成Connectable就很有必要。

很简单，publisher只需要调用.makeConnectable()就可以成为ConnectablePublisher。成为ConnectablePublisher后就可以调用下边两个方法：

  • connect
  • autoconnect

在上边的例子中，我们等待pipline建立完成后，调用了self.cancellable = publisher.connect(),从而开启了整个pipline。这是最常用的一个示例。

let publisher = Just("Hello, world")
    .share()
    .makeConnectable()
    .autoconnect()
复制代码

如果在.makeConnectable()之后，紧接着调用了.autoconnect()就相当于publisher没做任何事情，在真实的开发中，一定不要这么写代码。在下边的Timer中，我们还会用到这两个特性。

@Published

class PublishedViewObservableObject: ObservableObject {
    @Published var text: String = ""

    var cancellable: AnyCancellable?

    init() {
        cancellable = $text
            .sink(receiveValue: {
                print($0)
            })

        text = "hello, world"
    }
}
复制代码

@Published通常用在SwiftUI中的ObservableObject模型中，如果View依赖了该属性，当该属性改变时，View自动更新。

大家仔细看上边的代码，当我们调用$text的时候，它返回了一个publisher，这是为什么呢？ 我们看看Published的定义：

@propertyWrapper public struct Published {

    /// A publisher for properties marked with the `@Published` attribute.
    public struct Publisher : Publisher {

        /// The kind of values published by this publisher.
        public typealias Output = Value

        /// The kind of errors this publisher might publish.
        ///
        /// Use `Never` if this `Publisher` does not publish errors.
        public typealias Failure = Never

        /// Attaches the specified subscriber to this publisher.
        ///
        /// Implementations of ``Publisher`` must implement this method.
        ///
        /// The provided implementation of ``Publisher/subscribe(_:)-4u8kn``calls this method.
        ///
        /// - Parameter subscriber: The subscriber to attach to this ``Publisher``, after which it can receive values.
        public func receive(subscriber: S) where Value == S.Input, S : Subscriber, S.Failure == Published.Publisher.Failure
    }

    /// The property for which this instance exposes a publisher.
    ///
    /// The ``Published/projectedValue`` is the property accessed with the `$` operator.
    public var projectedValue: Published.Publisher { mutating get set }
}
复制代码

@propertyWrapper我们后续会有专门的文章讲解，Published内部有一个属性projectedValue，它就是一个publisher，我们可以用$符号访问。

Published并不是SwiftUI中才能用，它是Combine的特性，因此我们可以在任何class中使用：

class MyClass {
    @Published var text: String = ""

    var cancellable: AnyCancellable?

    init() {
        cancellable = $text
            .sink(receiveValue: {
                print($0)
            })

        text = "hello, MyClass"
    }
}
复制代码

NotificationCenter

extension Notification.Name {
    static let myCustomNotification = Notification.Name("myCustomNotification")
}

class NotificationCenterPublisherViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    init() {
        cancellable = NotificationCenter.default
            .publisher(for: .myCustomNotification)
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: {
                print($0)
            })

        NotificationCenter.default.post(name: .myCustomNotification, object: nil)
    }
}

/// Prints:
/// name = myCustomNotification, object = nil, userInfo = nil
复制代码

Combine也为NotificationCenter提供了publisher的能力，上边的代码已经给出了很明确的解释，在这里就不做更多解释了。

Timer

extension Timer {

    /// Returns a publisher that repeatedly emits the current date on the given interval.
    ///
    /// - Parameters:
    ///   - interval: The time interval on which to publish events. For example, a value of `0.5` publishes an event approximately every half-second.
    ///   - tolerance: The allowed timing variance when emitting events. Defaults to `nil`, which allows any variance.
    ///   - runLoop: The run loop on which the timer runs.
    ///   - mode: The run loop mode in which to run the timer.
    ///   - options: Scheduler options passed to the timer. Defaults to `nil`.
    /// - Returns: A publisher that repeatedly emits the current date on the given interval.
    public static func publish(every interval: TimeInterval, tolerance: TimeInterval? = nil, on runLoop: RunLoop, in mode: RunLoop.Mode, options: RunLoop.SchedulerOptions? = nil) -> Timer.TimerPublisher

    /// A publisher that repeatedly emits the current date on a given interval.
    final public class TimerPublisher : ConnectablePublisher {

        /// The kind of values published by this publisher.
        public typealias Output = Date

        /// The kind of errors this publisher might publish.
        ///
        /// Use `Never` if this `Publisher` does not publish errors.
        public typealias Failure = Never

        final public let interval: TimeInterval

        final public let tolerance: TimeInterval?

        final public let runLoop: RunLoop

        final public let mode: RunLoop.Mode

        final public let options: RunLoop.SchedulerOptions?

        /// Creates a publisher that repeatedly emits the current date on the given interval.
        ///
        /// - Parameters:
        ///   - interval: The interval on which to publish events.
        ///   - tolerance: The allowed timing variance when emitting events. Defaults to `nil`, which allows any variance.
        ///   - runLoop: The run loop on which the timer runs.
        ///   - mode: The run loop mode in which to run the timer.
        ///   - options: Scheduler options passed to the timer. Defaults to `nil`.
        public init(interval: TimeInterval, tolerance: TimeInterval? = nil, runLoop: RunLoop, mode: RunLoop.Mode, options: RunLoop.SchedulerOptions? = nil)

        /// Connects to the publisher, allowing it to produce elements, and returns an instance with which to cancel publishing.
        ///
        /// - Returns: A ``Cancellable`` instance that you use to cancel publishing.
        final public func connect() -> Cancellable
    }
}
复制代码

Timer是比较适合作为publisher的，通常来说，我们之所以使用Timer，就是需要按照固定的时间间隔来接收数据。

从上边的代码可以看出，如果想为Foundation框架中的元素增加Combine功能，只需要写一个extension就可以了，对于Timer，为它绑定一个TimerPublisher。

注意，TimerPublisher实现了ConnectablePublisher协议，因此它可以访问.autoconnect()和.connect()。

如果我们想自动开启定时器，代码是这样的：

cancellable = Timer.publish(every: 1.0, on: .main, in: .common)
    .autoconnect()
    .sink(receiveCompletion: {
        print($0)
    }, receiveValue: {
        print($0)
    })
复制代码

如果想手动控制连接，代码是这样的：

class TimerViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?
    var timerPublisher = Timer.publish(every: 1.0, on: .main, in: .common)
    var connectable: Cancellable?

    @Published var count: Int = 1

    init() {
    }

    func startTimer() {
        cancellable = timerPublisher
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: { _ in
                self.count += 1
            })

        connectable = timerPublisher
            .connect()
    }

    func stopTimer() {
        connectable?.cancel()
    }
}
复制代码

注意，当调用了connectable?.cancel(),就终止了该pipline，要想重新启动，需要重新开启订阅流程。

效果如下：

[图片上传中...(image-8a3f4f-1611739910251-0)]

KeyValueObservingPublisher

从事iOS开发的同学一定对kvo比较熟悉，简而言之，我们可以监听某个对象中属性的变化，我们就不详细介绍了，可以在这里Using Key-Value Observing in Swift了解详细信息。

class MyObjectToObserve: NSObject {
    @objc dynamic var myDate = NSDate(timeIntervalSince1970: 0) // 1970
    func updateDate() {
        myDate = myDate.addingTimeInterval(Double(2 << 30)) // Adds about 68 years.
    }
}
复制代码

class MyObserver: NSObject {
    @objc var objectToObserve: MyObjectToObserve
    var observation: NSKeyValueObservation?

    init(object: MyObjectToObserve) {
        objectToObserve = object
        super.init()

        observation = observe(
            \.objectToObserve.myDate,
            options: [.old, .new]
        ) { object, change in
            print("myDate changed from: \(change.oldValue!), updated to: \(change.newValue!)")
        }
    }
}
复制代码

虽然在平时的编码中，我们很少用到kvo，但Combine也为kvo增加了扩展，用法如下：

final class MyKeyValueClass: NSObject {
    @objc dynamic var name: String = ""
    @objc dynamic var age: Int = 20
}

class KeyValueObservingPublisherViewObservableObject: ObservableObject {
    var cancellable: AnyCancellable?

    init() {
        let keyValueClass = MyKeyValueClass()

        cancellable = keyValueClass.publisher(for: \.name)
            .sink(receiveCompletion: {
                print($0)
            }, receiveValue: {
                print($0)
            })

        keyValueClass.name = "James"
    }
}
复制代码
  • 在objc的类中用@objc dynamic声明属性
  • 使用keyValueClass.publisher(for: \.name)创建publisher

DataTaskPublisher

extension URLSession {

    /// Returns a publisher that wraps a URL session data task for a given URL.
    ///
    /// The publisher publishes data when the task completes, or terminates if the task fails with an error.
    /// - Parameter url: The URL for which to create a data task.
    /// - Returns: A publisher that wraps a data task for the URL.
    public func dataTaskPublisher(for url: URL) -> URLSession.DataTaskPublisher

    /// Returns a publisher that wraps a URL session data task for a given URL request.
    ///
    /// The publisher publishes data when the task completes, or terminates if the task fails with an error.
    /// - Parameter request: The URL request for which to create a data task.
    /// - Returns: A publisher that wraps a data task for the URL request.
    public func dataTaskPublisher(for request: URLRequest) -> URLSession.DataTaskPublisher

    public struct DataTaskPublisher : Publisher {

        /// The kind of values published by this publisher.
        public typealias Output = (data: Data, response: URLResponse)

        /// The kind of errors this publisher might publish.
        ///
        /// Use `Never` if this `Publisher` does not publish errors.
        public typealias Failure = URLError

        public let request: URLRequest

        public let session: URLSession

        public init(request: URLRequest, session: URLSession)
    }
}
复制代码

URLSession.shared.dataTaskPublisher(for url: URL)是网络请求中使用最频繁的publisher，值得注意的有以下几点：

  • Output = (data: Data, response: URLResponse)：它的输出类型是一个元组
  • Failure = URLError: 错误类型为URLError
  • 使用URL或URLRequest创建网络请求

Result.Publisher

class ResultPublisherViewViewObservableObject: ObservableObject {
    var cancellable1: AnyCancellable?
    var cancellable2: AnyCancellable?

    init() {

        enum MyError: Error {
            case custom
        }

        let publisher = Result.Publisher(.success(1))
            .share()

        cancellable1 = publisher
            .sink(receiveCompletion: {
                print("Stream 1 received: \($0)")
            }, receiveValue: {
                print("Stream 1 received: \($0)")
            })

        cancellable2 = publisher
            .sink(receiveCompletion: {
                print("Stream 2 received: \($0)")
            }, receiveValue: {
                print("Stream 2 received: \($0)")
            })
    }
}

/// Prints:
/// Stream 1 received: 1
/// Stream 1 received: finished
/// Stream 2 received: finished
复制代码

Result.Publisher主要用于发送是否成功或失败事件，如果是.success事件，则收到请求后就发送数据，然后再结束pipline, 而.faulure立即结束pipline。

其实Result.Publisher和Just很像,不同之处在于:

  • Result.Publisher可以发送数据+成功+失败
  • Just只能发送数据

你可能感兴趣的:(2021-01-27)

  • 2021-01-27 睫毛小梦
    今天来医院检查下，还是感觉心慌无力，气短。早上起来，医保卡找不到了。好久没用了，记得原来放在哪里希望老妈他们用，但是他们也一直没用。得找一下，找不到就补办一张吧，另外上锦医院的卡有了，后续就可以直接预约了。还是方便好多。公司的事还好，该安排的事都安排好了。但是今天产品好像出了个大bug,.不知道是不是昨天的回显改动导致的。估计要被骂了。先不管了。感觉心脏不舒服是加重了。身体最重要啊，身体是革命的本
  • 2021-01-27 邓老师_e37c
    不可多得的好剧—-《山海情》最近，《山海情》好评如潮。该剧讲述了上个世纪90年代宁夏西海固的人民和干部响应国家扶贫政策的号召，移民搬迁，在福建的对口帮扶下，艰苦奋斗，重建家园，将飞沙走石的戈壁荒漠干沙滩，建设成塞上江南“金沙滩”的动人故事。这部剧的剧情、场景、人物，都像脚下的黄土地一样的质朴、真实，让人动容。这部电视剧再现了那渐渐远去了的、激情燃烧的年代的身影，让我们这辈人重温起那段苦难与欢乐、汗
  • 2021-01-27 蒋铭国江西乐平
    方法总比困难多今天陈秀玉老师组织教育行走专属公众号“行走拓宽世界”编辑开了一个钉钉视频会。视频会议主要内容是回顾总结了之前的公众号推文情况，当然更主要的是让每一位编辑谈谈自己在推送过程中遇到的困难与疑惑。通过交流大家的意见都比较统一，那就是稿件的来源不是很丰富，还有原创文稿的质量，得不到较高的保证。为了解决这些问题，我谈了些自己的看法。在我谈自己的见解之前，谈了一下我自己在公号推文的情况。我之所以
  • 2021-01-27 韶华影月
    已经好几天没有学习英语了，我还有一个渴望就是，想拥有一口脱口而出的，能流利地和别人交流的英语。我要每天记单词，朗读背诵英语短文，在句子中去记单子，并学会运用。我一定可以的，我就是想做到可以给别人当导游，或者给别人翻译的程度。我有基础，趁现在还有时间，合适安排好时间，学习英语。时刻要记得自己想要的是什么才可以。
  • 2021-01-27 A樊登读书露露小书童
    《活好》日野原重明105岁写下本书日本皇家医生写了200多本著作一、如何看待死亡1.死亡——时时可死，步步求生。被你问到这个问题的时候，我就很怕死了，但是我也在努力的活着。2.珍惜疾病带给我们的东西，生病是另一种生活方式，感谢疾病带来的内省，疾病是上天的恩赐二、如何爱❤️1.如何解决观众不喜欢你的表演而表现不好：发自内心感谢观众2.爱一个最真实的他，你也会得到他同样的最真挚的热爱3.最至亲的人离世
  • 2021-01-27 NLDD_b112
    思乡刚刚翻看朋友圈，翻到了买我老家房子的姐姐。她的朋友圈照片挺多是在家里拍的，特别是疫情期间，闲得无聊发了好多照片。她买我家的房子就是因为相中了装修，所以除了孩子的房间稍作了一点改动，其他地方都没有什么变化。我翻她朋友圈的时候有种很矛盾的心理，一边想看看老家曾经住过的房子现在变成什么样了，一边又伤感的心中默念这里已经不再是我家了。从大学毕业去到上海，再到十年后来到海南，家已经成为了真正的远方。我还
  • 2021-01-27 学会使用Pr剪辑视频，会给你带来什么？ App严选君
    PR是一款专业的视频后期处理工具，从用手机拍摄的视频到Raw5K，都能导入并自由地组合，再以原生形式编辑，而不需花费时间转码；PR是视频专业人员的精选工具组合，具备强大、可自订、非线性的编辑器，可精准编辑视频等。新版2021版带来了全新的有嵌入式LUT的ARRIProRes格式的色彩管理，可更好的帮助用户处理出更生动的内容，以更好的制作出用户想要的优秀效果等。脸书、油管、推特上大火的男巫ZachK
  • 2021-01-27漫感&&天净沙·夏 澜莲Alice
    漫感龚自珍绝域从军计惘然，东南幽恨满词笺。一箫一剑平生意，负尽狂名十五年。天净沙·夏白朴〔元代〕云收雨过波添，楼高水冷瓜甜，绿树阴垂画檐。纱厨藤簟，玉人罗扇轻缣。夕次洛阳道中崔涂〔唐代〕秋风吹故城，城下独吟行。高树鸟已息，古原人尚耕。流年川暗度，往事月空明。不复叹岐路，马前尘夜生。
  • 2021-01-27橘子老师干货分享 正念中
    听到了什么1、请问大家你是否也觉得事情很多没有时间完成你想完成的事情？是的，想做的事情太多了，阻碍了行动正因为我们没有规划过我们的人生，生活中没有重点，所以即使你每天做了很多很多的事，你依旧会觉得最重要的事没有完成。2、立即行动来自梦想版中你近期的要事如果这个事情不重要你会去做吗？永远去做最重要的事3、被动学习，触发情绪主动学习才能更好精进4、你来这里是为了什么呢？初心很重要，找到自己的初心，不要
  • 2021-01-27 高丽华_b69b
    今天早上听了大家的分享，感觉到大家都非常有激情，这一点给我很大触动。还有两位主持人，用自己饱满的能量开启了今天的学习！我体会到能量真的会传递。看到同修们很快就完成复盘，并且内容都很详细，我就琢磨，为什么我没有听到这多内容呢？是自己的思想限制了自己的能力。我一听全是学员分享，不是教练讲课，从内心就没觉得能够学到干货，所以听完了也没有特别深刻的记忆。下一步目标，就是列清单，把每天要做的事情都写下来。做
  • 2021-01-27 散文的光芒
    做好以下五点，你的文章离出彩不远写作似乎是文人和作家的事，其实不然，你只要动笔，你就是一个作家，只是你作品的读者多少而已，不要太相信什么大家，其实都是普通人，不要用仰视的动作去看他们。在这个世界上永远相信只有自己是最棒的，世界上本没有天生的作家，即使有也都是后来打磨出来的。其实最早“作家”是管理家务的意思。而随着社会的发展及文化的进步，作家的内涵才逐渐发生改变，现在的作家泛指：以文化创作为业，以写
  • 2021-01-27面试题 Viewwei
    简述下html5的离线储存原理，同时说明如何使用？利用浏览的.appcache缓存机制(不是技术),通过appcache文件上面的解析清单离线缓存资源,这些资源会像cookie一样被存储下来.之后在利息那状态的时候,浏览器会通过离线存储的数据进行页面展示.页面头部加入一个manifest的属性...在cache.main文件编写离线存储的资源清单CACHEMANIFEST#v0.1//表示版本CA
  • 2021-01-27 大颖Haya
    2021年1月27日星期三《扫除道》读书总结今天阅读的是4个因为学校开展扫除道而发生巨大变化的学校。第一个案例是高中，杂草丛生，女生浓妆艳抹、男生衣装不整。约有一半的学生退学、校园暴力。展开扫除道活动以后，学生在其中，收获了做事情时的“投入”，脸上会露出清爽的笑容。在举行了三次清扫活动以后，时隔7年，这个学校再次举行了运动会。一群问题学生学会了团队协作。并且不认可的学生获得了鼓励。三年的时间，学校
  • 2021-01-27 潘jane
    姓名:潘珊群公司:宁波市镇海承迪文具有限公司盛和塾第456期六项精进反省一组成员（日精进打卡第760天）【知～学习】：《六项精进》背诵0遍共30遍.《大学》背诵0遍共30遍.朗读0遍共0遍.学习强国每天早上和晚上累计1小时以上······【经典名句分享】奇迹，是努力的另一个名字！【行～实践】一、修身：（对自己个人）1.晨起一杯温开水2.早睡早起3.多喝水4.每天一粒钙片5.饭后水果二、齐家：（对家
  • 2021-01-27 我允许，任何事情的发生 直冲上云霄
    今天发生的事又再次让我疑惑，老板到底什么意思，为什么前后的指令是如此的矛盾？后来才知道她是为了找存在感而已，并不是奔着解决事情本身而去的。。。。。。那这种核心思路，我真的是难以理解。好吧，只能心中默念一百遍：“我允许，任何事情的发生”------------------------------以下为摘抄，非常符合我的心境----------------------我允许，任何事情的发生。我允许，事
  • 2021-01-27 迟开四月花
    今天是阴天，吃过早饭又上起了大雾，这更加显得阴冷了。打扫完卫生，我便给老父亲清洗芋头，中午，我给老爹煮芋头。老爹来我家好几天了，因为老家拆迁，老爹的房子都拆了，已经过了三年，还没有住上新房呢。要不老爹才不愿意住我家呢。天也慢慢的放晴了，虽然还是有些阴冷，但太阳一出来还是让人感觉暖暖的。
  • 2021-01-27复盘《六项精进二阶第3天》 清筠
    很荣幸能成为今天的分享者！在这里要感谢3班七喜小姐姐，她给了我这次机会，感谢良哥把我带到这个社群，感谢教练每天分享的干货!!还有感谢缘分能认识大家，跟大家一起学习。今天的也是收获满满的!一、听到什么？1.心态成,事业成,不成也成。心态败,事业败,不败也败。2.确定目标：认真思考好好设定目标是非常重，不思考未来的人没有未来,过去没有成为很好的未来阶梯。并找一个拿到结果的人来监督我。3.不要凭感觉做事
  • 2021-01-27 duoruemi
    此刻，在高速上飞驰。先生开着车，我盘腿坐在副驾驶上，一边看书，一边听着车载音乐，时不时给先生喂点水果零食，偶尔再提醒先生注意车速，看上去我这个坐车的比开车的还操劳。歌曲一首接一首，遇着会唱的歌，还忍不住吼上两嗓子，行程中的快乐也不过如此了。先生唯一崇拜的一位女歌手，是孙燕姿，虽然近些年燕姿没出什么作品，但燕姿的老歌却是越听越有味道。这不，此刻先生正陶醉在燕姿的《我怀念的》里。恋爱时，先生说他从初中
  • 2021-01-27 贰壹5
    今天预约了一家远在三十公里开外的医院做复诊，早早就起床了结果等了好久好久的公交车，都没有来大概有两个小时吧，虽然这两小时等待的时间也没闲着，在学习，不过还是让人有一丝心烦最后干脆不等了，和医院说了一声临时有事，下次再约我想可能是因为快要过年了吧，公交司机比较少，也理解人生啊，要学会及时止损要懂得变通，不要一棵树上吊死
  • 2021-01-27 涂大本事
    小朋友和女孩子的无理取闹是不需要理由的。男女之间的差距和不平等因为根深蒂固太久了所以没能一下拉平也是可以理解的。女孩子是一个可爱的生物，小孩子也是。其实她们的开心真的很简单。表达出自己的欲望然后拥有了就开心得不到就哭。
  • 2021-01-27 “不知道”是解决团队难题的钥匙 朗月斋主
    为什么“不知道”竟然能够解决有挑战的问题？因为所谓“不知道”，是对再解决问题时坦诚、敬畏、包容、赋能的姿态。第一，坦诚把专业的事情交给专业的人，对专业保持敬畏。不要不懂装懂。世界上的知识门类越分越细，谁也不可能做一个百事通。对于自己不懂的事情要坦诚的承认并充分信任专业人员的能力。一个胜利的团队绝对不是依靠领导单枪匹马，而是方方面面互补能力的优势组合。带队出发第二，敬畏要有实事求是的问题意识。把每一
  • 2021-01-27疫情下的百态人生 森林走心篇章
    疫情下的百态人生那晚，大约22时左右。戴好口罩，手套去小区门口看看。小区门口此时冷冷清清，不复往日出来进去熙熙攘攘之景象。与值班防控的大叔攀谈，分析疫情形势，拉拉家常里短。大叔也是不容易，数九寒天，在小区门口临时搭建的帐篷里值班。帐篷里插着一个加热空调扇，距离近的确暖和，但是在室外，这点热乎劲根本无济于事，还是比较辛苦的。尤其是这时候，漫漫长夜，冬季的夜晚又是格外的长。辛苦，辛苦！过了大概半钟头，
  • 2021-01-27 A紫妍
    素颜风摆柳，端庄笑凡尘！初识她，相貌清新可人，让人眼前一亮，不由赞叹，好一位女子！已到深秋，树叶飘落，繁花落尽，薄凉萧条，连日的雨雪天气，心情似乎都没有了生气，文字在笔下也没有了色彩，然，看到风摆柳，像一片红枫叶翩翩的走来，让人不由得笔墨写意……空间相伴已有数月，虽很少聊天，默然闻香，寂静喜欢，喜欢居家做饭，相夫教子的女子，喜欢瑜伽和浅浅的文字，更喜欢她努力爱学，守着自己的一方小天地，过自己清幽的
  • 2021-01-27 李心语
    致良知线上课堂致知班学习66天时间：2021年1月27日姓名：李秀珍志愿：我立志成为一名温暖平和谦卑感恩无我利他，温暖别人，感动自己的致良知的践行者，传播者。｜当｜下｜即｜未｜来｜【自省利他致良知】今日功课1、读原文，准时交功课✔：2分2、日行一善✔：2分3、每日自省✔：2分（1）不抱怨，不说谎（2）时刻保持恩悲敬4、读书践行心得✔：2分（各30字以上）凡饮食只是要养我身，食了要消化；若徒蓄积在肚
  • 2021-01-27 可爱的坏人999
    人生有悲得不到想要的得到不想要的百炼千锤人生有苦喜欢与之无缘讨厌如影相陪猛打穷追人生有痛一心痴爱牢笼万种薄情憔悴长叹深悔浩浩烟波茫茫云水逢冷逢热靠争靠随
  • 2021-01-27 曾阿牛_666
    两条诫命，第二条爱邻如己.不管怎么说，从18年开始到如今已经3年了，坚持每天早起读经，还是有作用的，不管怎么说，反正治好了我的轻度抑郁症了。给了我勇敢的勇气了，靠着那加给我的力量凡事都可行。真的给了我勇敢前行的力量，而且要看懂很多西方经典文学名著，你有必要看过《新约》《旧约》全书的，要不然很多宗教概念你是不明白的。。。
  • 2021-01-27 骑驴书生
    读完莫言的《丰乳肥臀》已经有好几天了，也没有写相关读书笔记，真是对不起看完的这本书。毕竟看完了如果没有及时回顾和思考，那么便不能算看过这本书，只是看了文字的堆砌而已。这应该是特定的时代背景下的故事，讲的是一些可悲的小人物的经历。所谓可怜之人必有可恨之处，也是天道轮回报应不爽。也许，人的命啊，从出生就奠定了吧。
  • 2021-01-27（春节小忆） 蓝色印迹
    “小孩儿小孩儿你别馋，过了腊八就是年。腊八粥，喝几天，哩哩啦啦二十三。”眨眼间，春节马上到了，我不由想小时候家里过春节的光景。那时候，我们这些小孩子最喜欢过年，吃了一年的窝窝头啃咸菜，过年吃点水饺，吃几顿带肉的菜，解解一年的馋劲。我们家春节的习俗就是，过了腊月二十三开始，买肉肉、缝新衣等。如果年景好爸爸则是喜欢买一套猪头、猪下水，煮一大锅，过个丰盛的春节。我印象最深的就是，妈妈每年过了腊月二十六就
  • 2021-01-27 旅居人间山水
    近日，热播的电视剧《山海情》完结落幕，但是豆瓣评分却一路飙升到9.4。以前电视剧看的时候不少观众会觉得剧情拖沓想快进，但是这部剧看完后却让人意犹未尽。脱贫攻坚，在贫瘠土壤绽放希望《山海情》又为什么让观众回味无穷呢？是取景画面精美吗？不！村庄土掉渣，经常黄沙漫天。是服装华丽，制作精良？不！那是个当地特困村，甚至有三兄弟穷的只能穿一条裤子。那究竟是什么吸引了观众？是一群用双手创造奇迹的平凡人。在一个连
  • 2021-01-27 超_c165
    早安郑州2021-01-27星期三鼠庚子年腊月十五天气：多云1℃~12℃空气质量：168中度污染风向风力：静风0级【早安语录】只要你心存不甘，就还不到放弃的时候，所以请继续努力，不然永远都不知道结果，早安。【车辆限行】(尾号:3和8)本地号牌尾号限行;外地号牌尾号限行;新能源车辆不受限
  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
  • java编程思想 -- 数据的初始化 百合不是茶 java数据的初始化
      1.使用构造器确保数据初始化      /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
  • [航天与宇宙]为什么发射和回收航天器有档期 comsci
           地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁...        所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
  • linux下批量替换文件内容 商人shang linux替换
    1、网络上现成的资料 　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串 　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
  • 网页在线天气预报 oloz 天气预报
    网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
  • SpringMVC和Struts2比较 杨白白 springMVC
    1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。 参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
  • refuse copy, lazy girl! 小桔子 copy
           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！  
  • apache与php整合 aichenglong php apache web
    一  apache web服务器 1 apeche web服务器的安装   1)下载Apache web服务器   2)配置域名(如果需要使用要在DNS上注册)   3)测试安装访问http://localhost/验证是否安装成功 2 apache管理   1)service.msc进行图形化管理   2)命令管理，配
  • Maven常用内置变量 AILIKES maven
    Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
  • java的类和对象 百合不是茶 JAVA面向对象 类 对象
    java中的类：     java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决   java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的   创建一个A类： class A{ }   java中的类：将某两个事物有联系的属性包装在一个类中，再通
  • JS控制页面输入框为只读 bijian1013 JavaScript
    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。  
  • AngularJS与服务器交互 bijian1013 JavaScriptAngularJS$http
            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
  • [Maven学习笔记八]Maven常用插件应用 bit1129 maven
    常用插件及其用法位于：http://maven.apache.org/plugins/   1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin           1. Jetty Pl
  • 【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
    1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括： 文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
  • UI设计中我们为什么需要设计动效 brotherlamp UIui教程ui视频ui资料ui自学
    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。 但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。 一、加强体验舒适度 嗯，就是让用户更加爽更加爽的用你的产品。
  • Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan javaspring
    参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
  • 数据库连接池的工作原理 chicony 数据库连接池
           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
  • java 关键字 CrazyMizzz java
    关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：    （1）访问修饰符       public,private,protected       p
  • Hive中的排序语法 daizj 排序hiveorder byDISTRIBUTE BYsort by
    Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。 与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
  • 单态设计模式 dcj3sjt126com 设计模式
      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{    // 保存类实例在此属性中    private static&
  • svn locked dcj3sjt126com Lock
    post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
  • ARM寄存器学习 e200702084 数据结构C++cC#F#
    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。     ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）     不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
  • 常用编码资料 gengzg 编码
    List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
  • 进程 vs. 线程 hongtoushizi 线程linux进程
    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。 首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。 如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。 如果用多线程实现
  • Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linuxcrontab
    一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来： 第一段 代表分钟 0—59 第二段 代表小时 0—23 第三段 代表日期 1—31 第四段 代表月份 1—12 第五段 代表星期几，0代表星期日 0—6   如： */1 * * * *   每分钟执行一次。 *
  • KMP算法详解 hm4123660 数据结构C++算法字符串KMP
         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。       假设主串s="ababcabcacbab",模式串为t="
  • 枚举类型的单例模式 zhb8015 单例模式
    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
  • Kafka+Storm+HDFS ssydxa219 storm
    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
  • Java获取本地服务器的IP 中华好儿孙 javaWeb获取服务器ip地址
    System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他