Fluent interface-白红宇

In , a fluent interface (as first coined by and ) is an implementation of an API that aims to provide for more readable code.

A fluent interface is normally implemented by using (concretely ) to relay the instruction context of a subsequent call (but a fluent interface entails more than just method chaining ). 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[]

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 library in C++, which uses the << or >> for the message passing, sending multiple data to the same object and allowing "manipulators" for other method calls. Other early examples include the (from 1988 in Lisp) and the (from 1994 in C++) which used this style for object creation and property assignment.

Examples[]

Java[]

The 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 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 annotation processor enables the creation of a fluent API using Java annotations.

Also, the testing library 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 , 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.