DOCSEARCHbyAlgolia
Submit Docs

Chenyl8848 Technical Blog

website·Indexed 30 days ago

https://chenyl8848.github.io/

A collection of technical tutorials and guides covering Java, Spring 6, Spring Security + OAuth2, MySQL (Basic, Advanced, and Operations), Node.js, TypeScript, Vue 3, React, and WeChat Mini Programs. It also includes documentation on middleware and infrastructure such as Docker, Kubernetes, Redis, Kafka, RabbitMQ, ZooKeeper, ElasticSearch, and monitoring systems using Prometheus and Grafana.

Tokens
164.4K
Snippets
667
Records
906
Agent score
75%

What's inside Chenyl8848 Blog

  1. Overview of Vue 3 key features and improvements

    Vue 3 introduces several significant upgrades over previous versions:

    • Performance: Reduced bundle size by 41%, faster initial rendering (55%) and update rendering (133%), and 54% less memory usage.
    • Reactivity System: Now uses Proxy instead of defineProperty for reactivity.
    • TypeScript: Enhanced native support for TypeScript.
    • Composition API: Introduces setup, ref, reactive, watch, watchEffect, provide, and inject for better logic reuse.
    • New Built-in Components: Includes Fragment, Teleport, and Suspense.
    • Other Changes: New lifecycle hooks, requirement for data to be a function, and removal of keyCode as a v-on modifier.

  2. Overview of the Factory Design Pattern

    The Factory design pattern aims to decouple the main project from the instantiation of objects by extracting the object creation logic into a dedicated class. This centralization improves the scalability and maintainability of the project. There are three primary variations of this pattern: Simple Factory, Factory Method, and Abstract Factory.

  3. Overview of the Adapter Design Pattern

    The Adapter Pattern is a structural design pattern that converts the interface of a class into another interface that clients expect. Its primary purpose is compatibility, allowing two incompatible classes to work together. It is also known as a Wrapper. The user interacts with the target interface, and the adapter translates those calls into the adaptee's (source) interface, decoupling the client from the underlying implementation.

  4. Overview of the Decorator Design Pattern

    The Decorator pattern allows new functionality to be dynamically attached to an object. It provides a flexible alternative to subclassing for extending functionality and adheres to the Open-Closed Principle (OCP). It works by wrapping a core component with one or more decorator classes that add behavior while maintaining the same interface as the original component.

  5. Overview of the Java Concurrent (JUC) package

    JUC is the shorthand for the java.util.concurrent package. Introduced in JDK 1.5, it provides a comprehensive set of tools and utilities for handling multi-threaded programming and concurrency in Java.

  6. Overview of the Iterator Design Pattern

    The Iterator Pattern is a behavioral design pattern that provides a uniform interface for traversing elements of a collection without exposing the underlying representation (e.g., whether the collection is implemented as an array, a list, or another structure). This decouples the client from the internal structure of the collection.

  7. Overview of the Composite Design Pattern

    The Composite Pattern (also known as the Part-Whole pattern) is a structural design pattern used to compose objects into tree structures to represent part-whole hierarchies. It allows clients to treat individual objects (Leafs) and compositions of objects (Composites) uniformly.

    Key roles in the pattern:

    • Component: An interface or abstract class defining common operations for both simple and complex objects. It provides the base for accessing and managing child components.
    • Leaf: Represents the end objects of a composition. A leaf has no children.
    • Composite: A non-leaf node that stores child components. It implements the Component interface and provides methods to add or remove children.

  8. Overview of MyBatis-Plus features

    MyBatis-Plus (MP) is an enhancement tool for MyBatis designed to simplify development and improve efficiency without altering the original MyBatis functionality. Key features include:

    • Non-intrusive: Can be added to existing projects without impact.
    • Powerful CRUD: Built-in generic Mapper and Service for single-table operations and a condition constructor for complex queries.
    • Lambda Support: Allows writing query conditions using Lambda expressions to prevent field name typos.
    • Automatic Primary Key Generation: Supports 4 primary key strategies, including a distributed unique ID generator (Sequence).
    • ActiveRecord Pattern: Entity classes inheriting from Model can perform CRUD operations directly.
    • Code Generator: Generates Mapper, Model, Service, and Controller layers via code or Maven plugins.
    • Pagination Plugin: Provides physical pagination across multiple databases (MySQL, Oracle, PostgreSQL, SQLServer, etc.).
    • Performance Analysis: Built-in plugin to output SQL statements and execution time to identify slow queries.
    • Global Interceptor: Prevents accidental full-table delete or update operations.

  9. Overview of the Builder Design Pattern

    The Builder Pattern (also known as the Generator Pattern) is a creational design pattern used to construct complex objects step-by-step. It abstracts the construction process into a separate class, allowing the same construction process to create different representations of an object. This isolates the client from the internal details of how the object is assembled.

  10. Overview of the Seven Core Design Principles

    Design patterns are used to improve software quality by addressing challenges related to coupling, cohesion, maintainability, extensibility, reusability, and flexibility. The seven core design principles that serve as the foundation for these patterns are:

    1. Single Responsibility Principle (SRP)
    2. Interface Segregation Principle (ISP)
    3. Dependency Inversion Principle (DIP)
    4. Liskov Substitution Principle (LSP)
    5. Open-Closed Principle (OCP)
    6. Law of Demeter (LoD)
    7. Composite Reuse Principle

  11. Overview of Netty Framework

    Netty is an open-source, asynchronous, event-driven Java network application framework designed for developing high-performance, highly reliable network IO programs. It is essentially an NIO framework optimized for high-concurrency applications under the TCP protocol or Peer-to-Peer scenarios involving continuous large data transfers.

  12. Overview of the Singleton Design Pattern

    The Singleton design pattern ensures that a class has only one instance throughout the entire software system and provides a global point of access to that instance via a static method. A common real-world example is the Hibernate SessionFactory, which is resource-heavy and should only be instantiated once per project.