ಎಲೋಕ್ವೆಂಟ್ ಜೊತೆ ಉಪಯುಕ್ತ ರೆಪೊಸಿಟರಿಗಳು?

ಕಳೆದ ವಾರ ನಾನು ಬರೆದಿದ್ದೇನೆ ನಿರರ್ಗಳ ಘಟಕಗಳಿಗೆ ರೆಪೊಸಿಟರಿ ಟೆಂಪ್ಲೇಟ್‌ನ ಅನುಪಯುಕ್ತತೆಯ ಕುರಿತು ಲೇಖನ, ಆದಾಗ್ಯೂ, ಅದನ್ನು ತನ್ನ ಅನುಕೂಲಕ್ಕೆ ಹೇಗೆ ಭಾಗಶಃ ಬಳಸಬೇಕೆಂದು ನನಗೆ ಹೇಳಲು ಅವರು ಭರವಸೆ ನೀಡಿದರು. ಇದನ್ನು ಮಾಡಲು, ಈ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಯೋಜನೆಗಳಲ್ಲಿ ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿಶ್ಲೇಷಿಸಲು ನಾನು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ. ರೆಪೊಸಿಟರಿಗಾಗಿ ಕನಿಷ್ಠ ಅಗತ್ಯವಿರುವ ವಿಧಾನಗಳ ಸೆಟ್:

<?php
interface PostRepository
{
    public function getById($id): Post;
    public function save(Post $post);
    public function delete($id);
}

ಆದಾಗ್ಯೂ, ನೈಜ ಯೋಜನೆಗಳಲ್ಲಿ, ರೆಪೊಸಿಟರಿಗಳನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದರೆ, ದಾಖಲೆಗಳನ್ನು ಹಿಂಪಡೆಯುವ ವಿಧಾನಗಳನ್ನು ಅವುಗಳಿಗೆ ಹೆಚ್ಚಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ:

<?php
interface PostRepository
{
    public function getById($id): Post;
    public function save(Post $post);
    public function delete($id);

    public function getLastPosts();
    public function getTopPosts();
    public function getUserPosts($userId);
}

ಈ ವಿಧಾನಗಳನ್ನು ಎಲೋಕ್ವೆಂಟ್ ಸ್ಕೋಪ್‌ಗಳ ಮೂಲಕ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಆದರೆ ತಮ್ಮನ್ನು ತಾವು ಪಡೆದುಕೊಳ್ಳುವ ಜವಾಬ್ದಾರಿಯೊಂದಿಗೆ ಘಟಕದ ವರ್ಗಗಳನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡುವುದು ಉತ್ತಮ ಉಪಾಯವಲ್ಲ, ಮತ್ತು ಈ ಜವಾಬ್ದಾರಿಯನ್ನು ಭಂಡಾರ ತರಗತಿಗಳಿಗೆ ವರ್ಗಾಯಿಸುವುದು ತಾರ್ಕಿಕವಾಗಿ ತೋರುತ್ತದೆ. ಇದು ಹೀಗಿದೆಯೇ? ನಾನು ನಿರ್ದಿಷ್ಟವಾಗಿ ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಈ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಎರಡು ಭಾಗಗಳಾಗಿ ವಿಂಗಡಿಸಿದೆ. ವಿಧಾನಗಳ ಮೊದಲ ಭಾಗವನ್ನು ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಪ್ರಮಾಣಿತ ಬರವಣಿಗೆ ಕಾರ್ಯಾಚರಣೆ:

• ಹೊಸ ವಸ್ತುವಿನ ನಿರ್ಮಾಣ ಮತ್ತು ಸವಾಲು ಪೋಸ್ಟ್ ರೆಪೊಸಿಟರಿ :: ಉಳಿಸಿ
• ಪೋಸ್ಟ್ ರೆಪೊಸಿಟರಿ::getById, ಘಟಕದ ಕುಶಲತೆ ಮತ್ತು ಸಮನ್ಸ್ ಪೋಸ್ಟ್ ರೆಪೊಸಿಟರಿ :: ಉಳಿಸಿ
• ಒಂದು ಸವಾಲು ಪೋಸ್ಟ್ ರೆಪೊಸಿಟರಿ :: ಅಳಿಸಿ

ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳು ಪಡೆಯುವ ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಓದುವ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ, ಪಡೆಯಿರಿ* ವಿಧಾನಗಳನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ. ನೀವು ಬಗ್ಗೆ ಓದಿದರೆ ಇಂಟರ್ಫೇಸ್ ಪ್ರತ್ಯೇಕತೆಯ ತತ್ವ (ಪತ್ರ I в ಸಾಲಿಡ್), ನಂತರ ನಮ್ಮ ಇಂಟರ್ಫೇಸ್ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಮತ್ತು ಕನಿಷ್ಠ ಎರಡು ವಿಭಿನ್ನ ಜವಾಬ್ದಾರಿಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ಅದನ್ನು ಎರಡರಿಂದ ಭಾಗಿಸುವ ಸಮಯ. ವಿಧಾನ getById ಎರಡರಲ್ಲೂ ಇದು ಅವಶ್ಯಕವಾಗಿದೆ, ಆದರೆ ಅಪ್ಲಿಕೇಶನ್ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದಂತೆ, ಅದರ ಅನುಷ್ಠಾನಗಳು ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ನಾವು ಇದನ್ನು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ನೋಡುತ್ತೇವೆ. ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ ಬರೆಯುವ ಭಾಗದ ನಿಷ್ಪ್ರಯೋಜಕತೆಯ ಬಗ್ಗೆ ನಾನು ಬರೆದಿದ್ದೇನೆ, ಆದ್ದರಿಂದ ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಅದನ್ನು ಮರೆತುಬಿಡುತ್ತೇನೆ.

ಓದು ಭಾಗವು ನನಗೆ ಅಷ್ಟೊಂದು ನಿಷ್ಪ್ರಯೋಜಕವಲ್ಲ ಎಂದು ತೋರುತ್ತದೆ, ಏಕೆಂದರೆ ವಾಕ್ಚಾತುರ್ಯಕ್ಕಾಗಿ ಸಹ ಇಲ್ಲಿ ಹಲವಾರು ಅನುಷ್ಠಾನಗಳು ಇರಬಹುದು. ವರ್ಗವನ್ನು ಹೆಸರಿಸಲು ಏನು? ಮಾಡಬಹುದು ರೀಡ್ಪೋಸ್ಟ್ ರೆಪೊಸಿಟರಿ, ಆದರೆ ಟೆಂಪ್ಲೇಟ್‌ಗೆ ರೆಪೊಸಿಟರಿಯನ್ನು ಅವನಿಗೆ ಈಗಾಗಲೇ ಸ್ವಲ್ಪ ಪ್ರಸ್ತುತತೆ ಇದೆ. ನೀವು ಕೇವಲ ಮಾಡಬಹುದು ಪೋಸ್ಟ್ ಕ್ವರೀಸ್:

<?php
interface PostQueries
{
    public function getById($id): Post;
    public function getLastPosts();
    public function getTopPosts();
    public function getUserPosts($userId);
}

ಎಲೋಕ್ವೆಂಟ್‌ನೊಂದಿಗೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ತುಂಬಾ ಸರಳವಾಗಿದೆ:

<?php
final class EloquentPostQueries implements PostQueries
{
    public function getById($id): Post
    {
        return Post::findOrFail($id);
    }

    /**
    * @return Post[] | Collection
    */
    public function getLastPosts()
    {
        return Post::orderBy('created_at', 'desc')
            ->limit(/*some limit*/)
            ->get();
    }
    /**
    * @return Post[] | Collection
    */
    public function getTopPosts()
    {
        return Post::orderBy('rating', 'desc')
            ->limit(/*some limit*/)
            ->get();
    }

    /**
    * @param int $userId
    * @return Post[] | Collection
    */
    public function getUserPosts($userId)
    {
        return Post::whereUserId($userId)
            ->orderBy('created_at', 'desc')
            ->get();
    }
}

ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಅನುಷ್ಠಾನದೊಂದಿಗೆ ಸಂಯೋಜಿಸಬೇಕು, ಉದಾಹರಣೆಗೆ ಇನ್ AppServiceProvider:

<?php
final class AppServiceProvider extends ServiceProvider 
{
    public function register()
    {
        $this->app->bind(PostQueries::class, 
            EloquentPostQueries::class);
    }
}

ಈ ವರ್ಗವು ಈಗಾಗಲೇ ಉಪಯುಕ್ತವಾಗಿದೆ. ನಿಯಂತ್ರಕರು ಅಥವಾ ಘಟಕ ವರ್ಗವನ್ನು ನಿವಾರಿಸುವ ಮೂಲಕ ಅವನು ತನ್ನ ಜವಾಬ್ದಾರಿಯನ್ನು ಅರಿತುಕೊಳ್ಳುತ್ತಾನೆ. ನಿಯಂತ್ರಕದಲ್ಲಿ ಇದನ್ನು ಈ ರೀತಿ ಬಳಸಬಹುದು:

<?php
final class PostsController extends Controller
{
    public function lastPosts(PostQueries $postQueries)
    {
        return view('posts.last', [
            'posts' => $postQueries->getLastPosts(),
        ]);
    }
} 

ವಿಧಾನ PostsController :: lastPosts ಕೆಲವು ಅನುಷ್ಠಾನಕ್ಕಾಗಿ ಕೇಳುತ್ತಿದೆ ಪೋಸ್ಟ್‌ಕ್ವರೀಸ್ ಮತ್ತು ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ನಾವು ಲಿಂಕ್ ಮಾಡಿದ ಪೂರೈಕೆದಾರರಲ್ಲಿ ಪೋಸ್ಟ್ ಕ್ವರೀಸ್ ವರ್ಗದೊಂದಿಗೆ ಎಲೋಕ್ವೆಂಟ್ ಪೋಸ್ಟ್ ಕ್ವರೀಸ್ ಮತ್ತು ಈ ವರ್ಗವನ್ನು ನಿಯಂತ್ರಕಕ್ಕೆ ಬದಲಿಸಲಾಗುತ್ತದೆ.

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಬಹಳ ಜನಪ್ರಿಯವಾಗಿದೆ ಎಂದು ಊಹಿಸೋಣ. ಪ್ರತಿ ನಿಮಿಷಕ್ಕೆ ಸಾವಿರಾರು ಬಳಕೆದಾರರು ಇತ್ತೀಚಿನ ಪ್ರಕಟಣೆಗಳೊಂದಿಗೆ ಪುಟವನ್ನು ತೆರೆಯುತ್ತಾರೆ. ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಪ್ರಕಟಣೆಗಳನ್ನು ಸಹ ಆಗಾಗ್ಗೆ ಓದಲಾಗುತ್ತದೆ. ಡೇಟಾಬೇಸ್‌ಗಳು ಅಂತಹ ಲೋಡ್‌ಗಳನ್ನು ಚೆನ್ನಾಗಿ ನಿಭಾಯಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವು ಪ್ರಮಾಣಿತ ಪರಿಹಾರವನ್ನು ಬಳಸುತ್ತವೆ - ಸಂಗ್ರಹ. ಡೇಟಾಬೇಸ್ ಜೊತೆಗೆ, ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲಾದ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ - ಮೆಮ್ಕಾಚೆಡ್ ಅಥವಾ ರೆಡಿಸ್.

ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ತರ್ಕವು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ, ಆದರೆ EloquentPostQueries ನಲ್ಲಿ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ತುಂಬಾ ಸರಿಯಾಗಿಲ್ಲ (ಏಕೆಂದರೆ ಏಕ ಜವಾಬ್ದಾರಿ ತತ್ವ) ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚು ನೈಸರ್ಗಿಕವಾಗಿದೆ ಅಲಂಕಾರಕಾರ ಮತ್ತು ಮುಖ್ಯ ಕ್ರಿಯೆಗಾಗಿ ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಅಲಂಕಾರವಾಗಿ ಅಳವಡಿಸಿ:

<?php
use IlluminateContractsCacheRepository;

final class CachedPostQueries implements PostQueries
{
    const LASTS_DURATION = 10;

    /** @var PostQueries */
    private $base;

    /** @var Repository */
    private $cache;

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

    /**
    * @return Post[] | Collection
    */
    public function getLastPosts()
    {
        return $this->cache->remember('last_posts', 
            self::LASTS_DURATION, 
            function(){
                return $this->base->getLastPosts();
            });
    }

    // другие методы практически такие же
}

ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ರೆಪೊಸಿಟರಿಯನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ. ಕೆಲವು ಅಜ್ಞಾತ ಕಾರಣಗಳಿಗಾಗಿ, ಅವರು Laravel ನಲ್ಲಿ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಈ ರೀತಿ ಹೆಸರಿಸಲು ನಿರ್ಧರಿಸಿದರು.

ಕ್ಲಾಸ್ CachedPostQueries ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯನ್ನು ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. $this->cache->ನೆನಪಿಡಿ ಈ ನಮೂದು ಸಂಗ್ರಹದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ, ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗೆ ಕರೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಮರಳಿದ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಕ್ಕೆ ಬರೆಯುತ್ತದೆ. ಈ ವರ್ಗವನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅಳವಡಿಸಲು ಮಾತ್ರ ಉಳಿದಿದೆ. ಇಂಟರ್‌ಫೇಸ್‌ನ ಅನುಷ್ಠಾನವನ್ನು ವಿನಂತಿಸಲು ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ವರ್ಗಗಳು ನಮಗೆ ಅಗತ್ಯವಿದೆ ಪೋಸ್ಟ್ ಕ್ವರೀಸ್ ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ಪ್ರಾರಂಭಿಸಿತು CachedPostQueries. ಆದಾಗ್ಯೂ, ಅವನು ಸ್ವತಃ CachedPostQueries ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಒಂದು ವರ್ಗವನ್ನು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಸ್ವೀಕರಿಸಬೇಕು ಎಲೋಕ್ವೆಂಟ್ ಪೋಸ್ಟ್ ಕ್ವರೀಸ್ಏಕೆಂದರೆ ಇದು "ನೈಜ" ಅನುಷ್ಠಾನವಿಲ್ಲದೆ ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ನಾವು ಬದಲಾಗುತ್ತೇವೆ AppServiceProvider:

<?php
final class AppServiceProvider extends ServiceProvider 
{
    public function register()
    {
        $this->app->bind(PostQueries::class, 
            CachedPostQueries::class);

        $this->app->when(CachedPostQueries::class)
            ->needs(PostQueries::class)
            ->give(EloquentPostQueries::class);
    }
}

ನನ್ನ ಎಲ್ಲಾ ಶುಭಾಶಯಗಳನ್ನು ಒದಗಿಸುವವರಲ್ಲಿ ಸಹಜವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ. ಹೀಗಾಗಿ, ನಾವು ಒಂದು ವರ್ಗವನ್ನು ಬರೆಯುವ ಮೂಲಕ ಮತ್ತು ಕಂಟೇನರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ನಮ್ಮ ವಿನಂತಿಗಳಿಗೆ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯನ್ನು ಅಳವಡಿಸಿದ್ದೇವೆ. ಉಳಿದ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಬದಲಾಗಿಲ್ಲ.

ಸಹಜವಾಗಿ, ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಅಮಾನ್ಯೀಕರಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಸಹ ಅಗತ್ಯವಾಗಿದೆ, ಇದರಿಂದಾಗಿ ಅಳಿಸಿದ ಲೇಖನವು ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ ಸೈಟ್ನಲ್ಲಿ ಸ್ಥಗಿತಗೊಳ್ಳುವುದಿಲ್ಲ, ಆದರೆ ತಕ್ಷಣವೇ ಅಳಿಸಲಾಗುತ್ತದೆ. ಆದರೆ ಇವು ಚಿಕ್ಕ ವಿಷಯಗಳು.

ಬಾಟಮ್ ಲೈನ್: ನಾವು ಒಂದಲ್ಲ, ಎರಡು ಟೆಂಪ್ಲೆಟ್ಗಳನ್ನು ಬಳಸಿದ್ದೇವೆ. ಮಾದರಿ ಕಮಾಂಡ್ ಕ್ವೆರಿ ರೆಸ್ಪಾನ್ಸಿಬಿಲಿಟಿ ಸೆಗ್ರಿಗೇಶನ್ (CQRS) ಇಂಟರ್ಫೇಸ್ ಮಟ್ಟದಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ಓದುವ ಮತ್ತು ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಪ್ರಸ್ತಾಪಿಸುತ್ತದೆ. ನಾನು ಮೂಲಕ ಅವನ ಬಳಿಗೆ ಬಂದೆ ಇಂಟರ್ಫೇಸ್ ಪ್ರತ್ಯೇಕತೆಯ ತತ್ವ, ನಾನು ಕೌಶಲ್ಯದಿಂದ ಮಾದರಿಗಳು ಮತ್ತು ತತ್ವಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ಮತ್ತು ಒಂದು ಪ್ರಮೇಯವಾಗಿ ಇನ್ನೊಂದರಿಂದ ಪಡೆಯುತ್ತೇನೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ :) ಸಹಜವಾಗಿ, ಪ್ರತಿಯೊಂದು ಯೋಜನೆಗೆ ಘಟಕಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಅಂತಹ ಅಮೂರ್ತತೆಯ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ನಾನು ನಿಮ್ಮೊಂದಿಗೆ ಟ್ರಿಕ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇನೆ. ಅಪ್ಲಿಕೇಶನ್‌ನ ಆರಂಭಿಕ ಹಂತದಲ್ಲಿ ಅಭಿವೃದ್ಧಿ, ನೀವು ಸರಳವಾಗಿ ವರ್ಗವನ್ನು ರಚಿಸಬಹುದು ಪೋಸ್ಟ್ ಕ್ವರೀಸ್ ಎಲೋಕ್ವೆಂಟ್ ಮೂಲಕ ಸಾಮಾನ್ಯ ಅನುಷ್ಠಾನದೊಂದಿಗೆ:

<?php
final class PostQueries
{
    public function getById($id): Post
    {
        return Post::findOrFail($id);
    }

    // другие методы
}

ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಅಗತ್ಯವು ಉದ್ಭವಿಸಿದಾಗ, ಸರಳ ಚಲನೆಯೊಂದಿಗೆ ನೀವು ಈ ವರ್ಗದ ಸ್ಥಳದಲ್ಲಿ ಇಂಟರ್ಫೇಸ್ (ಅಥವಾ ಅಮೂರ್ತ ವರ್ಗ) ರಚಿಸಬಹುದು ಪೋಸ್ಟ್ ಕ್ವರೀಸ್, ಅದರ ಅನುಷ್ಠಾನವನ್ನು ವರ್ಗಕ್ಕೆ ನಕಲಿಸಿ ಎಲೋಕ್ವೆಂಟ್ ಪೋಸ್ಟ್ ಕ್ವರೀಸ್ ಮತ್ತು ನಾನು ಮೊದಲು ವಿವರಿಸಿದ ಯೋಜನೆಗೆ ಹೋಗಿ. ಉಳಿದ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ತರಗತಿಗಳು, ಇಂಟರ್ಫೇಸ್‌ಗಳೊಂದಿಗೆ ಈ ಎಲ್ಲಾ ತಂತ್ರಗಳು, ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ и CQRS ನಲ್ಲಿ ವಿವರವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ ನನ್ನ ಪುಸ್ತಕ "ಆರ್ಕಿಟೆಕ್ಚರ್ ಆಫ್ ಕಾಂಪ್ಲೆಕ್ಸ್ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಸ್". ಈ ಲೇಖನದ ಉದಾಹರಣೆಗಳಲ್ಲಿ ನನ್ನ ಎಲ್ಲಾ ವರ್ಗಗಳನ್ನು ಏಕೆ ಅಂತಿಮ ಎಂದು ಗುರುತಿಸಲಾಗಿದೆ ಎಂಬ ಒಗಟಿಗೆ ಪರಿಹಾರವೂ ಇದೆ.

ಮೂಲ: www.habr.com