8.4k sao GitHub và vẫn tăng — steipete/Aspects là dự án Objective-C mà TopGit đang theo dõi trên nền tảng. Delightful, simple library for aspect oriented programming in Objective-C and Swift.
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Aspects v1.4.2 🪝 - AOP for Objective-C (10k+ stars)
A delightful, simple library for aspect oriented programming by @steipete.
Think of Aspects as method swizzling on steroids. It allows you to add code to existing methods per class or per instance, whilst thinking of the insertion point e.g. before/instead/after. Aspects automatically deals with calling super and is easier to use than regular method swizzling.
Aspects hooks deep into the class hierarchy and creates dynamic subclasses, much like KVO. There's known issues with this approach, and to this date (February 2019) I STRICTLY DO NOT RECOMMEND TO USE Aspects IN PRODUCTION CODE. We use it for partial test mocks in, PSPDFKit, an iOS PDF framework that ships with apps like Dropbox or Evernote, it's also very useful for quickly hacking something up.
Aspects uses _objc_msgForward which causes issues with other code that uses message forwarding.
Aspects extends NSObject with the following methods:
/// Adds a block of code before/instead/after the current `selector` for a specific class.
///
/// @param block Aspects replicates the type signature of the method being hooked.
/// The first parameter will be `id<AspectInfo>`, followed by all parameters of the method.
/// These parameters are optional and will be filled to match the block signature.
/// You can even use an empty block, or one that simple gets `id<AspectInfo>`.
///
/// @note Hooking static methods is not supported.
/// @return A token which allows to later deregister the aspect.
+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
withOptions:(AspectOptions)options
usingBlock:(id)block
error:(NSError **)error;
/// Adds a block of code before/instead/after the current `selector` for a specific instance.
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
withOptions:(AspectOptions)options
usingBlock:(id)block
error:(NSError **)error;
/// Deregister an aspect.
/// @return YES if deregistration is successful, otherwise NO.
id<AspectToken> aspect = ...;
[aspect remove];
Adding aspects returns an opaque token of type AspectToken which can be used to deregister again. All calls are thread-safe.
Aspects uses Objective-C message forwarding to hook into messages. This will create some overhead. Don't add aspects to methods that are called a lot. Aspects is meant for view/controller code that is not called 1000 times per second.
Aspects calls and matches block arguments. Blocks without arguments are supported as well. The first block argument will be of type id<AspectInfo>.
When to use Aspects
Aspect-oriented programming (AOP) is used to encapsulate "cross-cutting" concerns. These are the kind of requirements that cut-across many modules in your system, and so cannot be encapsulated using normal object oriented programming. Some examples of these kinds of requirements:
Whenever a user invokes a method on the service client, security should be checked.
Whenever a user interacts with the store, a genius suggestion should be presented, based on their interaction.
All calls should be logged.
If we implemented the above requirements using regular OOP there'd be some drawbacks:
Good OOP says a class should have a single responsibility, however adding on extra cross-cutting requirements means a class that is taking on other responsibilites. For example you might have a StoreClient that is supposed to be all about making purchases from an online store. Add in some cross-cutting requirements and it might also have to take on the roles of logging, security and recommendations. This is not great because:
Our StoreClient is now harder to understand and maintain.
These cross-cutting requirements are duplicated and spread throughout our app.
AOP lets us modularize these cross-cutting requirements, and then cleanly identify all of the places they should be applied. As shown in the examples above cross-cutting requirements can be either technical or business focused in nature.
Here are some concrete examples:
Aspects can be used to dynamically add logging for debug builds only:
Another convenient use case is adding handlers for classes that you don't own. I've written it for use in PSPDFKit, where we require notifications when a view controller is being dismissed modally. This includes UIKit view controllers like MFMailComposeViewController and UIImagePickerController. We could have created subclasses for each of these controllers, but this would be quite a lot of unnecessary code. Aspects gives you a simpler solution for this problem:
@implementation UIViewController (DismissActionHook)
// Will add a dismiss action once the controller gets dismissed.
- (void)pspdf_addWillDismissAction:(void (^)(void))action {
PSPDFAssert(action != NULL);
[self aspect_hookSelector:@selector(viewWillDisappear:) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
if ([aspectInfo.instance isBeingDismissed]) {
action();
}
} error:NULL];
}
@end
Debugging
Aspects identifies itself nicely in the stack trace, so it's easy to see if a method has been hooked:
Using Aspects with non-void return types
You can use the invocation object to customize the return value:
You can also add the two files Aspects.h/m to your project. There are no further requirements.
Compatibility and Limitations
Aspects uses quite some runtime trickery to achieve what it does. You can mostly mix this with regular method swizzling.
An important limitation is that for class-based hooking, a method can only be hooked once within the subclass hierarchy. See #2
This does not apply for objects that are hooked. Aspects creates a dynamic subclass here and has full control.
KVO works if observers are created after your calls aspect_hookSelector: It most likely will crash the other way around. Still looking for workarounds here - any help appreciated.
Because of ugly implementation details on the ObjC runtime, methods that return unions that also contain structs might not work correctly unless this code runs on the arm64 runtime.
Credits
The idea to use _objc_msgForward and parts of the NSInvocation argument selection is from the excellent ReactiveCocoa from the GitHub guys. This article explains how it works under the hood.
Supported iOS & SDK Versions
Aspects requires ARC.
Aspects is tested with iOS 7+ and OS X 10.7 or higher.
License
MIT licensed, Copyright (c) 2014 Peter Steinberger, [email protected], @steipete
Release Notes
Version 1.4.2
Allow to hook different subclasses.
Smaller tweaks.
Version 1.4.1
Rename error codes.
Version 1.4.0
Add support for block signatures that match method signatures. (thanks to @nickynick)
Version 1.3.1
Add support for OS X 10.7 or higher. (thanks to @ashfurrow)
Version 1.3.0
Add automatic deregistration.
Checks if the selector exists before trying to hook.
Improved dealloc hooking. (no more unsafe_unretained needed)
Better examples.
Always log errors.
Version 1.2.0
Adds error parameter.
Improvements in subclassing registration tracking.
Version 1.1.0
Renamed the files from NSObject+Aspects.m/h to just Aspects.m/h.
Removing now works via calling remove on the aspect token.
Allow hooking dealloc.
Fixes infinite loop if the same method is hooked for multiple classes. Hooking will only work for one class in the hierarchy.
Additional checks to prevent things like hooking retain/release/autorelease or forwardInvocation:
The original implementation of forwardInvocation is now correctly preserved.
Classes are properly cleaned up and restored to the original state after the last hook is deregistered.
steipete/Aspects thuộc nhóm Mobile trên TopGit, cùng 5 topic GitHub. Trang Trending và Topics liệt kê các repo cùng số sao và cùng ngôn ngữ để so sánh.
Đọc thêm về steipete/Aspects ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/steipete/Aspects là nguồn chính thức.
steipete/Aspects có bao nhiêu sao?
steipete/Aspects có 8.4k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/steipete/Aspects. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
steipete/Aspects có những chủ đề gì?
GitHub topics của steipete/Aspects: "aspects", "hooks", "objective-c", "objectivec", "swift". TopGit xếp repo vào nhóm Mobile.
steipete/Aspects có phải mã nguồn mở không?
Có — steipete/Aspects phát hành theo license MIT, nghĩa là mã nguồn mở để đọc, fork và (tùy license) tái sử dụng. Mã: github.com/steipete/Aspects.
steipete/Aspects có trang demo không?
Dự án có trang chủ ở https://twitter.com/steipete. Tab "Readme" ở trang này thường có ảnh chụp và hướng dẫn bắt đầu nhanh.
steipete/Aspects còn đang phát triển không?
Commit gần nhất trên steipete/Aspects là 11 tháng trước (theo timestamp GitHub). Repo có 1.3k fork — một chỉ báo về mức độ quan tâm của cộng đồng.
Đọc đầy đủ README ở tab phía trên.
Muốn nghe thêm một ý kiến về Aspects?
Hỏi một AI đọc được trang này — một cú bấm là có ngay nhận định về Aspects.