Java Advanced Software Architect Training Phase II

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: http://www.itsource.com.cn/thread-26-1-3.html

Java Advanced Software Architect Training Phase II