What are Contracts in Laravel? Complete Guide with Examples

Laravel is known for its clean architecture and flexibility. One of the core concepts that helps achieve this is Contracts. Contracts provide a way to define the behavior of a class without specifying its implementation.

If you want to write scalable, maintainable, and testable code in Laravel, understanding contracts is very important.

---

What are Contracts in Laravel?

In Laravel, contracts are simply interfaces that define a set of methods a class must implement. They act as a blueprint for functionality.

Instead of depending on a concrete class, you depend on an interface (contract). Laravel then resolves the actual implementation using the service container.

Simple Example

use Illuminate\Contracts\Cache\Repository;

class UserController {
    protected $cache;

    public function __construct(Repository $cache) {
        $this->cache = $cache;
    }

    public function getUser() {
        return $this->cache->get('user');
    }
}

Here, Repository is a contract, and Laravel automatically provides its implementation.

---

How Contracts Work Internally

::contentReference[oaicite:0]{index=0}

Laravel uses the Service Container to resolve contracts.

• You type-hint a contract (interface)
• Laravel finds its binding in the container
• It injects the correct implementation automatically

This process is called Dependency Injection.

---

Why Use Contracts?

• Loose Coupling: Code is not tied to a specific implementation
• Better Testing: Easy to mock dependencies
• Flexibility: Swap implementations without changing code
• Clean Architecture: Improves maintainability

---

Common Laravel Contracts

• Cache Repository – Caching system
• Mailer – Sending emails
• Queue – Job queues
• Auth Guard – Authentication

---

Contracts vs Facades

Feature	Contracts	Facades
Type	Interface	Static-like class
Testing	Easy	Harder
Flexibility	High	Medium

---

Creating a Custom Contract

Step 1: Create Interface

interface PaymentInterface {
    public function pay();
}

Step 2: Create Implementation

class RazorpayPayment implements PaymentInterface {
    public function pay() {
        return "Paid via Razorpay";
    }
}

Step 3: Bind in Service Container

$this->app->bind(PaymentInterface::class, RazorpayPayment::class);

Step 4: Use It

class PaymentController {
    public function __construct(PaymentInterface $payment) {
        $this->payment = $payment;
    }
}

---

Real-World Use Case

In real applications like payment systems, you may need to support multiple gateways such as Stripe, Razorpay, or PayPal.

Using contracts, you can switch between implementations easily without changing your core logic.

---

Advantages of Contracts

• Improves code flexibility
• Enhances testability
• Promotes clean architecture

Disadvantages of Contracts

• More setup required
• Can feel complex for beginners

---

Final Thoughts

Contracts in Laravel are a powerful way to build flexible and maintainable applications. By relying on interfaces instead of concrete classes, you can easily swap implementations and write cleaner code.

If you are building scalable applications or preparing for interviews, mastering contracts is essential.