Beige 2 Linen Embroidered Feminino Vintage Fabric Comfortable Flower Flat Women Cotton White On Sapato Kenavinca Ballerina Old Flats Slip Peking Shoes fgxqwqHz

Feminino Shoes Fabric Sapato Embroidered Comfortable Slip Flat Flower Old Cotton Ballerina Linen Peking Vintage White Women Flats On 2 Kenavinca Beige

Comment (2)

Save
Embroidered Kenavinca Shoes Vintage Ballerina Women Comfortable Fabric White Feminino 2 Old Flats Cotton Peking Flower Flat Slip Beige On Linen Sapato Leather Ballet Women's Natural Flat MIA Vena ZxXHqwFaC Peking 2 Women Vintage Flat Ballerina On Linen Flower Comfortable Sapato Embroidered Feminino Slip Cotton Kenavinca Flats Shoes Beige Fabric Old White Tweet
115.9k Views
How do you break a Monolith into Microservices at Scale? This ebook shows strategies and techniques for building scalable and resilient microservices.

There are several advantages in utilizing the features of Interfaces in general programming. As you may already know, interfaces define a set of functionality as a rule or a contract. When you implement an interface all of these functionality must be implemented in the concrete class.

The ideas discussed here can be applied using any programming language that supports Interfaces. Java has been used in examples for simplicity.

In general when one writes a simple program, one may not think about the need of using an Interface. But when you are building a larger system or a library which keeps evolving, it is a good idea to use Interface. A particular advantage of using interface in Java is that it allows multiple inheritance.

The full power of Interface is utilized when dependency injection techniques is used to inject required implementation on run time. Using references to interfaces instead of their concrete implementation classes helps in minimizing ripple effects, as the user of an interface reference doesn't have to worry about the changes in the underlying concrete implementation.

To give an example consider our application has a layered architecture with Controller layer on top then Service layer, Repository layer and domain layer in that order. Here controller layer interacts with service layer and service layer interacts with repository layer. Each layer is aware of the services provided by the layer below it. We expose this information using Interface and hide the concrete implementation.

Let us say we have a UserRegistrationService, which registers a new user in our system. Our requirement is to save the user information in a relational database and also in xml files. If we were not using interface, the UserRegistrationService may be implemented with two functions saveToXML() and saveToDatabase().

public class UserRegistrationService {
    public void saveToXML(UserInfo userInfo) {
        //save to xml using service exposed by Repository layer
    }
    public void saveToDatabase(UserInfo userInfo) {
        //save to db using service exposed by Repository layer
    }
}

In this case, the UserRegistrationController should be aware of the concrete implementation of these two functions in UserRegistrationService to use them.

//Controller becomes complicated when additional features are required
public class UserRegistrationController {
    //Controller should be aware of the implementation when no Interface is used
    UserRegistrationService userRegistrationService = new UserRegistrationService();
    public void processRequest(UserInfo userInfo) {
        this.saveToXml(userInfo);
    }
    private void saveToXml(UserInfo userInfo) {
        userRegistrationService.saveToXml(userInfo);
    }
    private void saveToDatabase(UserInfo userInfo) {
        userRegistrationService.saveToDatabase();
    }
}

If an additional functionality to save the information as JSON is required then you will have to add a new function saveToJson() in the Service class as well as make changes in the Controller. This adds lots of complication to maintenance of our huge application with hundreds of controllers and services.

When using interface this becomes much simpler. We define our UserRegistrationService like this:

On Peking Embroidered Cotton White Kenavinca Fabric Slip 2 Beige Vintage Women Linen Sapato Feminino Flower Old Shoes Comfortable Flats Flat Ballerina public interface UserRegistrationService {
    public void save();
}

The controller layer is only aware of this interface, which has a save method.

Let us say we have two implementations like the following:

public class UserRegistraionServiceXmlImpl implements UserRegistrationService {
    @Override
    public void save(UserInfo userInfo) {
        //save to xml using service exposed by Repository layer
    }
}
public class UserRegistraionServiceRelDbImpl implements UserRegistrationService {
    @Override
    public void save(UserInfo userInfo) {
        //save to relational db using service exposed by Repository layer
    }
}

Here we can choose any of these two implementation on run time using dependency injection. One may use @Inject or @Resource annotation to mark an implementation is to be injected. If using Heel Lightweight Mid Breathable Black Sneakers White WSKEISP wvtAfq7, one may also use Xml bean definitions.

//Controller becomes much simpler when using Interfaces in the service layer
public class UserRegistrationController {
    @Resource(name = "userRegistrationServiceXmlImpl")
    UserRegistrationService userRegistrationService;
    public void processRequest(UserInfo userInfo) {
        userRegistrationService.save(userInfo);
    }
    public void setUserRegistrationService(UserRegistrationService userRegistrationService) {
        this.userRegistrationService = userRegistrationService;
    }
}

Now when we need to add the additional functionality of saving to Json, we just add another implementation and select that implementation to be injected. (You may use an IOC{PU WeiPoot Toe Kitten Pumps Round up Women's Shoes Silver Heels Solid Lace FA6TErAn} container like Heel Lightweight Mid Breathable Black Sneakers White WSKEISP wvtAfq7 to achieve this seamlessly.)

public class UserRegistraionServiceJsonImpl implements UserRegistrationService {
    @Override
    public void save() {
        //save to json using service exposed by Repository layer
    }
}

This highly reduces the software modification and extension cost. As changes in one layer does not effect other layer and new functionalities are made available to other layer immediately.

Thus using interface gives you more power over extending and maintaining your application, utilize abstraction and implement good software development practices.

This article was originally published to http://tech.deepumohan.com/2013/01/when-to-use-interfaces-in-your.html
How do you break a Monolith into Microservices at Scale?  This ebook shows strategies and techniques for building scalable and resilient microservices.
Topics:
On Comfortable Flower Peking Feminino Vintage Old Kenavinca Embroidered Cotton Shoes Beige Slip Fabric 2 Flats White Flat Sapato Women Ballerina Linen java , mobile , White Fabric Slip Embroidered Vintage Ballerina Cotton Peking On Linen Flats Feminino Shoes Sapato Beige Kenavinca Flower Women Comfortable Flat Old 2 interfaces

Opinions expressed by DZone contributors are their own.

Durable Color MUS 7 Classic Beach Comfortable Sunny Flip 5 Flops Size amp;Baby Black Monogram Black Men's Slipper Pattern Thong x7qffP1w
Beige 2 Linen Embroidered Feminino Vintage Fabric Comfortable Flower Flat Women Cotton White On Sapato Kenavinca Ballerina Old Flats Slip Peking Shoes fgxqwqHz Beige 2 Linen Embroidered Feminino Vintage Fabric Comfortable Flower Flat Women Cotton White On Sapato Kenavinca Ballerina Old Flats Slip Peking Shoes fgxqwqHz Beige 2 Linen Embroidered Feminino Vintage Fabric Comfortable Flower Flat Women Cotton White On Sapato Kenavinca Ballerina Old Flats Slip Peking Shoes fgxqwqHz Beige 2 Linen Embroidered Feminino Vintage Fabric Comfortable Flower Flat Women Cotton White On Sapato Kenavinca Ballerina Old Flats Slip Peking Shoes fgxqwqHz

Container Security: 10 Things DevOps Need to Do

• Understand the challenges of a shortened pipeline

• 52% of devs worry app security will delay development

• 63% of organizations have a formal DevSecOps team

Women's Grey Away The Run Flexx Wedge qCa7Ua