Online Java advanced Software Architect Training Stage II

Source: Internet
Author: User
Tags failover lua browser cache varnish redis cluster

No. 01 Session: Overview of the overall course

-----------------------The following is a distributed architecture and Deployment Section------------------------------------------------------------------

No. 02 Lesson: The basic knowledge of distributed deployment and the evolution of system distributed deployment part I.
No. 03 Lesson: The Evolution of system distributed deployment the second part; problems caused by distributed deployment
No. 04 Lesson: Inter-module invocation: Problems, scenarios, self-realization of the development of the program the first part
No. 05 Session: Development of self-Realization program Part II
No. 06 Lesson: The development of self-Realization program Part III; more questions to consider
No. 07 Lesson: Unified Session Management: Issues, scenarios, ideas, code examples Part I
No. 08 Lesson: code example Part II; more questions
No. 09 Lesson: Single Sign-on: questions, scenarios, ideas, code examples Part I
10th Lesson: code example Part Two
11th session: Consistency Update: Issues, scenarios, ideas
12th Lesson: code example the first part
13th Lesson: code Example Part Two
14th Lesson: Distributed transactions: Issues, scenarios, ideas, especially the idea of implementing logical transaction processing by itself
15th Lesson: Code Sample processing of distributed transactions
16th Lesson: High Availability: Issues, scenarios, HA basics
17th Lesson: keepalived Introduction, realization of ideas; VRRP protocol
18th session: Keepalived Installation and architecture
19th session: Keepalived Configuration
20th lesson: The first part of Keepalived+nginx ha
21st Lesson: The second part of Keepalived+nginx ha
22nd session: Keepalived ha, such as: Varnish, Tomcat, Redis, MySQL, etc.
23rd Lesson: LVS Foundation; Keepalived+lvs for high-availability load balancing

-----------------------the following sections for high concurrency and the performance optimization of the Web tier----------------------------------------------------------

24th Lesson: The basic idea of high concurrency and high concurrency processing-1: From the client Perspective
Lesson 25th: The basic idea of high concurrency processing-2, the basic means of high concurrency processing-1
26th Lesson: Basic means of high concurrency processing -2:web server level, Web application level, Database level
27th lesson: Nginx Optimization Supplement: Configuration Optimization Supplement, nginx configuration using two-level domain name
Class 28th: Varnish Optimization Supplement-1: Backend changes, how to proactively notify varnish update cache
29th Lesson: Varnish Optimization Supplement-2: Page fragment cache ESI
30th lesson: Varnish Optimization Supplement-3: Output varnish log-to-file, and log Format customization
31st lesson: Web Cache basics, types; browser cache Basics
32nd Lesson: Browser Caching working mechanism and control
33rd lesson: Reverse Proxy Server Cache
34th lesson: Varnish+esi application example; web App caching for pages
35th lesson: Static basics and implementation ideas; static example first part
36th Lesson: Static Example Part Two
37th lesson: static Example Part III; Test static function, experience its performance improvement
38th lesson: Web Representation Call Process Analysis
39th Lesson: Understanding Latency, browser rendering processing, The basic optimization idea of Web Layer
40th Lesson: Overview of performance optimization of Web performance layer; Connect network and send request part optimization idea
41st lesson: Connecting the network and sending the optimization of the request section
42nd Lesson: Optimization ideas and means for transmitting content in the network back and forth
43rd lesson: Optimization of server processing request part--tomcat Basic Optimization
44th lesson: Tomcat BIO/NIO/APR Three modes, installing and configuring Test Apr
45th lesson: Optimization of the server processing request part-- Common optimizations for JavaScript
46th lesson: The optimization ideas and means of the browser rendering drawing section
47th Lesson: Comprehensive application of the previously learned optimization methods, optimization of the sample application, testing and understanding of performance improvements
48th lesson: Tomcat Cluster, A non-viscous solution for the unified management of the session by MSM
49th Lesson: MSM's Sticky scheme for session unified management, Tomcat failover, memcached failover
Lesson 50th: Working with dynamic content in static pages: ESI, AJAX

-----------------------the following sections for logical layer processing and performance tuning-------------------------------------------------------------

51st session: Introduction to Redis, comparison with other databases or cache servers, installation
52nd Lesson: Redis Basics, data types, manipulating commands on keys
53rd lesson: Manipulating commands on string types, manipulating commands on list types
54th Lesson: Operation command for set type, Operation command for hash type
55th Lesson: Operation commands for the Zset type
56th Lesson: Sorting command details, handling outdated keys mechanisms and commands
57th Lesson: Redis Configuration Details -1:config commands, common parts, restricted sections
58th lesson: Redis Persistence Overview, RDB Principles, RDB issues, action commands
59th Lesson: aof principle, aof log recovery, aof rewrite, aof override trigger mechanism, AOF rewrite fundamentals
60th Lesson: Overview of Redis transactions, basic procedures, error handling, basic commands; Overview of the publication subscription model for Redis, operations commands
61st Lesson: Redis Replication: Benefits, configuration, basic operations commands, Fundamentals
62nd Lesson: Configuration Details of the replication section, optimistic replication strategy, no hard disk copy, Sentinel function
63rd Lesson: Redis Clusters: Replication issues, shards, common Shard implementations, Redis Shard drawbacks, cluster architecture, cluster operations basic commands
64th Lesson: Manually create a Redis cluster in one step by command
65th Lesson: Slots, Key-to-slot relationships, moving assigned slots, command for slot operations, fault determination, and recovery
66th lesson: Using REDIS-TRIB.RB to create and manipulate clusters; Redis Pre-partitioning
67th Lesson: Lua Script Development-1: Introduction, data type, variables, operators, if statements
68th Lesson: Lua Scripting 2: Looping statements, table types, functions, LUA's standard library
69th Lesson: Lua Scripting-3: Standard library functions, other library functions commonly used in Redis
70th lesson: Redis and Lua binding, Redis operations in scripts, commands for manipulating LUA scripts, and processing of random numbers and random results by sandbox and Redis
71st Lesson: Lua Scripting Object-oriented: MetaTable, object-oriented writing; modular
72nd Lesson: Redis Security, Redis Management, Understanding Redis virtual memory, scenarios for using Redis
73rd Lesson: Redis Optimization: Optimization recommendations, best practices, etc.
74th Lesson: Redis Java Client-1: Building a development environment, basic development
75th Lesson: Redis Java Client-2: Connection pool, connection cluster (new cluster notation)
76th Lesson: Redis Java Client-3: Connecting clusters (old Sharedjedis); Redis and Spring integrated development
77th lesson: Using Redis-1 in a sample project: Implementing basic increment, delete, change, and query by ID method
78th Lesson: Using Redis-2 in a sample project: Building features that use LUA scripting to implement conditional queries by using LUA scripting
79th lesson: Using Redis-3 in a sample project: implementing conditionally querying; Starting to implement paging functionality
80th Lesson: Using Redis-4 in a sample project: Implementing paging functionality, working with existing projects, working in projects
81st Lesson: Caching planning, including: data planning, technical planning, deployment environment planning, scalability, expansion of the scheduled program, etc.
82nd lesson: memcached clusters, demonstrating direct use of client implementations
83rd Lesson: Demonstrating the use of magent to implement memcached clusters
84th Lesson: Asynchronous programming, including: Planning of asynchronous messages, technical planning, deployment environment planning, etc.
85th Lesson: Performance optimization for ACTIVEMQ-based applications: test to determine the problem, and to tell the idea of optimization
86th Lesson: Demonstrating the implementation of specific optimization scenarios for asynchronous performance optimization-1
87th Lesson: Demonstrating the implementation of specific optimization scenarios for asynchronous performance optimization-2
88th Lesson: Demonstrating the implementation of specific optimization scenarios for asynchronous performance optimization-3
89th lesson: Demonstrating the implementation of specific optimization scenarios for asynchronous performance optimization-4
90th Lesson: Testing and initially demonstrating the effects of asynchronous performance optimizations
91st lesson: pure Memory operations-dealing with complex business logic, telling ideas and basic business descriptions
92nd lesson: Addressing specific solutions, from relatively simple to complex applications
93rd lesson: Demonstrating the implementation of a specific solution for pure memory operations-1
94th Lesson: Demonstrating the implementation of a specific solution for pure memory operations-2
95th Lesson: Demonstrating the implementation of a specific solution for pure memory operations-3
96th Lesson: Demonstrating the implementation of a specific solution for pure memory operations-4
97th lesson: The processing of high concurrency business Part I: Problems, solutions, preparation stage processing, front-end page processing
98th session: Processing of high concurrency Business Part II: Processing of the logical layer and processing of other related parts

-----------------------the following sections for data-tier processing and performance tuning-------------------------------------------------------------

99th Lesson: Big Data Volume Processing: Problems, solutions, specific solutions and solutions
100th session: MySQL partition-1: partition base, partition type, range partition
101th session: MySQL partition -2:list partition, hash partition, linear hash partition, key partition
102th lesson: MySQL Partition-3: Sub-partition, partition management, partition use some basic rules
103th Lesson: Sub-database sub-1: Why to divide the table, what is the sub-Library, what is the sub-table, and their advantages and disadvantages
104th Lesson: Sub-database sub-2: How to divide the library, how to divide the table, the sub-database after the problem of the table
The 105th lesson: The realization of the horizontal sub-table-1: Some related open source products, and their implementation of the general idea, the status quo is to achieve their own
The 106th lesson: the realization of the horizontal sub-table-2: Basic realization thinking, achievable level analysis
107th Lesson: Code Presentation Level Sub-table implementation-1: Design ideas, navigation table design, etc.
108th Lesson: Code Presentation Level Sub-table implementation-2: Code implementation navigation, separate calls, and merge processing, etc.
109th session: MySQL Fabric-1: Overview, Basic concepts, Basic installation configuration
110th Lesson: MySQL fabric-2:ha Configuration use, sharding configuration use

-----------------------The following section for database Performance tuning-------------------------------------------------------------------

111th Lesson: MySQL Master-slave replication: basic implementation of the principle, common topology, and the specific use of the configuration; MySQL read-write separation
112th lesson: Galera for MySQL cluster-1: Overview, features, basic concepts, basic copy process, usage notes
113th lesson: Galera for MySQL cluster-2: Installation configuration, demo of copy function, common monitoring management commands
114th lesson: Ha and load balancing for MySQL: Why needs, common architectures, demos of implementation scenarios
115th session: SQL Optimization method: Intercepting SQL statements, identifying problematic SQL statements, confirming statement execution, statement parsing, statement optimization, optimization validation
116th lesson: Common MySQL server configuration optimizations; NoSQL applications; Description of other content
Download Link:

Online Java advanced Software Architect Training Stage II

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.