Application layer query language PHP library

<?php
namespace Sandbox;
use Youshido\GraphQL\Execution\Processor;
use Youshido\GraphQL\Schema\Schema;
use Youshido\GraphQL\Type\Object\ObjectType;
use Youshido\GraphQL\Type\Scalar\StringType;
require_once __DIR__ . '/../../../../../vendor/autoload.php';
$processor = new Processor(new Schema([
    'query' => new ObjectType([
        'name'   => 'RootQueryType',
        'fields' => [
            'currentTime' => [
                'type'    => new StringType(),
                'resolve' => function () {
                    return date('Y-m-d H:ia');
                }
            ]
        ]
    ])
]));
$processor->processPayload('{ currentTime }');
echo json_encode($processor->getResponseData()) . "\n";
　

1. When clearing and updating the cache, try to operate the objects affected by the update as accurately as possible, rather than destroying them all.
In Hibernate, it also provides a fine-grained method of clearing cache objects such as sessionFactory.evict(class, id).
​​​​The operation of sessionFactory.evice(class) depends on whether such operations are frequent. If they are frequent, the effect of caching will be greatly reduced.
　2. If there are too many cached objects, the invalidation algorithm and processing should be closely combined with the characteristics of the business object, and the object invalidation should be driven by events.
　3. For caching of commercial objects, it is necessary to deeply analyze the life cycle and business characteristics of the objects.
　4. It is necessary to have sufficient understanding and prevention measures for the risks of data inconsistency.
　5. Reasonably estimate the size of the order object and allocate enough memory
　6. If you only use the central cache, you can only reduce the pressure on the database. There is still pressure on network bandwidth, and the speed is far inferior to the effect of local cache. Therefore, the strategy of local cache + central cache should be combined, that is, to improve speed and avoid bottlenecks during cluster replication.