您现在的位置是：首页 > 文章详情

Fluent interface

日期：2018-01-06点击：721收藏

In software engineering , a fluent interface (as first coined by Eric Evans and Martin Fowler ) is an implementation of an object oriented API that aims to provide for more readable code.

A fluent interface is normally implemented by using method cascading (concretely method chaining) to relay the instruction context of a subsequent call (but a fluent interface entails more than just method chaining ^[1]). Generally, the context is

defined through the return value of a called method
self-referential, where the new context is equivalent to the last context
terminated through the return of a void context.

History[edit]

The term "fluent interface" was coined in late 2005, though this overall style of interface dates to the invention of method cascading in Smalltalk in the 1970s, and numerous examples in the 1980s. The most familiar is the iostream library in C++, which uses the << or >>operators for the message passing, sending multiple data to the same object and allowing "manipulators" for other method calls. Other early examples include the Garnet system (from 1988 in Lisp) and the Amulet system (from 1994 in C++) which used this style for object creation and property assignment.

Examples[edit]

Java[edit]

The jOOQ library models SQL as a fluent API in Java

 
            Author a = AUTHOR.as(
            "a"
            ); 
           
            create.selectFrom(a)
           
            .where(exists(selectOne() 
           
            .from(BOOK) 
           
            .where(BOOK.STATUS.eq(BOOK_STATUS.SOLD_OUT)) 
           
            .and(BOOK.AUTHOR_ID.eq(a.ID))));

The op4j library enables the use of fluent code for performing auxiliary tasks like structure iteration, data conversion, filtering, etc.

 
            String[] datesStr = 
            new 
            String[] {
            "12-10-1492"
            , 
            "06-12-1978"
            }; 
           
            ...
           
            List<Calendar> dates =
           
            Op.on(datesStr).toList().map(FnString.toCalendar(
            "dd-MM-yyyy"
            )).get();

The fluflu annotation processor enables the creation of a fluent API using Java annotations.

Also, the mock object testing library EasyMock makes extensive use of this style of interface to provide an expressive programming interface.

 
            Collection mockCollection = EasyMock.createMock(Collection.
            class
            ); 
           
            EasyMock.expect(mockCollection.remove(
            null
            )).andThrow(
            new 
            NullPointerException()).atLeastOnce();

In the Java Swing API, the LayoutManager interface defines how Container objects can have controlled Component placement. One of the more powerful LayoutManager implementations is the GridBagLayout class which requires the use of the GridBagConstraints class to specify how layout control occurs. A typical example of the use of this class is something like the following.

 
            GridBagLayout gl = 
            new 
            GridBagLayout(); 
           
            JPanel p = 
            new 
            JPanel(); 
           
            p.setLayout( gl );
           
            JLabel l = 
            new 
            JLabel(
            "Name:"
            ); 
           
            JTextField nm = 
            new 
            JTextField(
            10
            ); 
           
            GridBagConstraints gc = 
            new 
            GridBagConstraints(); 
           
            gc.gridx = 
            0
            ; 
           
            gc.gridy = 
            0
            ; 
           
            gc.fill = GridBagConstraints.NONE;
           
            p.add( l, gc );
           
            gc.gridx = 
            1
            ; 
           
            gc.fill = GridBagConstraints.HORIZONTAL;
           
            gc.weightx = 
            1
            ; 
           
            p.add( nm, gc );

This creates a lot of code and makes it difficult to see what exactly is happening here. The Packer class, visible at http://java.net/projects/packer/, provides a Fluent mechanism for using this class so that you would instead write:

 
            JPanel p = 
            new 
            JPanel(); 
           
            Packer pk = 
            new 
            Packer( p ); 
           
            JLabel l = 
            new 
            JLabel(
            "Name:"
            ); 
           
            JTextField nm = 
            new 
            JTextField(
            10
            ); 
           
            pk.pack( l ).gridx(
            0
            ).gridy(
            0
            ); 
           
            pk.pack( nm ).gridx(
            1
            ).gridy(
            0
            ).fillx();

There are many places where Fluent APIs can greatly simplify how software is written and help create an API language that helps users be much more productive and comfortable with the API because the return value of a method always provides a context for further actions in that context.

==============================================================================

本文转自被遗忘的博客园博客，原文链接：http://www.cnblogs.com/rollenholt/p/3655461.html，如需转载请自行联系原作者

原文链接：https://yq.aliyun.com/articles/336677

关注公众号

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。

持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

转载内容版权归作者及来源网站所有，本站原创内容转载请注明来源。