Online Java advanced Software Architect training Stage One

Source: Internet
Author: User
Tags create index mongodb query varnish nginx reverse proxy

No. 01 Session: Overview of the overall course content

-----------------------the MAVEN supplement and git sections below------------------------------------------------------------------

No. 02 Session: Maven Supplement: Sub-module, sub-project management
No. 03 Lesson: Maven Supplement: Multi-module, multi-Web application, combined into a war package
No. 04 Lesson: Git Quick start: git Introduction, Fundamentals, installation, git server configuration, plugin Egit
No. 05 session: Git Quick start: tortoisegit local use
No. 06 session: Git Quick start: egit local use
No. 07 Lesson: Git Quick Start: remote use of Tortoisegit and Egit, and conflict resolution, including: content conflicts, tree conflicts, logical conflicts

-----------------------The following is the basic business Function block build section------------------------------------------------------------------

No. 08 Lesson: Introduction to basic business functions to be completed, basic data dictionary
No. 09 Lesson: Building a basic development environment: Eclipse+maven+git
10th lesson: Using Spring+mybatis to implement the DAO portion of customer
11th lesson: MyBatis's pagination implementation, DAO's simple test
12th session: Implementation of the Service section, and basic development of the underlying module
13th Lesson: Implementing Web Layer development based on spring MVC
14th Lesson: Basic Add and List pages, and tag development and testing for pagination
15th lesson: Development and testing of pagination, modification, and deletion pages with query criteria
16th session: Query page, mybatis dynamic query implementation, JSON automatic assembly
17th Lesson: Refining public Webmodel, starting X-gen generated template making, making DAO part of the template
18th lesson: Making X-gen to generate the required service, Web layer templates
19th lesson: Making X-gen to generate the required data, and the corresponding visitor
20th lesson: Making X-gen generate the action you need, and some of the visitor
21st Lesson: Generating commodity modules through X-gen, and adjusting the entire generated templates and programs
22nd lesson: Generating cart modules through X-gen, and adjusting the entire generated templates and programs
23rd Lesson: Generate Order Master module, Detail module and Inventory management module through X-gen
24th lesson: Adding Ehcache to the Client management module and adding the existing project to Git
25th Lesson: Realize front-end business login, homepage and other functions
26th lesson: Testing and adjusting login business functions, using cookies to save user information
27th Lesson: Achieving the development of the index function
28th Lesson: Index and Product detailed description page implementation, Shopping cart implementation
29th Lesson: The ability to complete placing orders and modifying inventory
30th lesson: Configuring and deploying basic business applications to a Linux server

-----------------------Below is the Nginx part------------------------------------------------------------------

31st Session: Nginx Introduction, Installation and basic operation
32nd session: Nginx's process structure, basic configuration, etc.
33rd lesson: The function and configuration of Nginx Common Core module instruction
34th lesson: The features and configuration of the Nginx HTTP Module section are used
35th Lesson: The function and configuration of Nginx location section use
36th Lesson: The function and configuration of Nginx reverse proxy module is used
37th lesson: Nginx Combined with practical application, to realize the function of reverse proxy and static and dynamic separation
38th lesson: Nginx Load Balancer module, and the configuration of the actual application
39th Lesson: The configuration and use of Nginx rewrite module
40th Lesson: Nginx more Modules basic functions and configuration, common features of the configuration example
41st session: Nginx Configuration optimization and usage recommendations
42nd Lesson: How architecture changes after you apply the Nginx architecture, and under greater traffic

-----------------------below is the varnish section------------------------------------------------------------------

43rd session: Varnish Introduction, installation and basic use
44th Lesson: Introduction to VCL, basic syntax, and basic configuration usage, including load-balanced configuration
45th Lesson: VCL To configure functions for health check, ACL access control, etc.
46th Lesson: Understanding and application of Grace mode and Saint mode
47th Lesson: Functions commonly used in VCL and common HTTP headers
48th Lesson: Sub-procedures for VCL, ation and understanding the request process
49th Lesson: Variables for VCL, common VCL application fragments
50th lesson: Using the CLI to manage varnish, mastering how to clear the cache, VARNISHADM commands
51st lesson: varnishd Command and run-time parameters, understanding the functions of parameters and options
52nd session: Varnish log operations and varnish shared memory: Varnishlog, Varnishtop, Varnishhist, varnishsizes, Varnishnsca, Varnishreplay
53rd Lesson: Planning varnish cache size; Varnishstat statistics; increasing the hit rate of varnish
54th session: Varnish performance tuning and basic configuration usage recommendations
55th lesson: Combine varnish and basic applications with Nginx.
56th session: Basic performance testing; varnish monitoring and preliminary optimization
57th Lesson: Architecture After application of varnish, and evolution of architecture

-----------------------below is the memcached section------------------------------------------------------------------

58th Lesson: memcached Introduction, meaning of the cache, installation, basic configuration, startup, and basic use
59th Lesson: memcached Basic Working principle, two-stage hash; memcached command: Set, add, replace, append, prepend, CAs, get, gets, delete, INCR/DECR, etc.
60th Lesson: Stats command, stats sizes command, flush_all command, Version command, stats settings, stats items, stats slabs block statistics, etc.
61st Lesson: Understanding how memcached data is stored, understanding how slab allocator, understanding the new item allocation memory process
62nd Lesson: Chunk of memory allocation, slab allocation demonstration, memcached of data storage methods; Understanding how memcached Data Expires: lazy/lazy expiration, LRU, lazy delete mechanism
63rd session: memcached Java Client Development, memcached, and spring integration development
64th Lesson: Understanding the distributed approach of memcached, distributed distribution in terms of the remainder, consistent hash algorithm, virtual node
65th lesson: memcached Memory Tuning recommendations, tuning objectives, tuning methods, solving common problems, using Memcached-tool to assist with tuning
66th Lesson: Memcached Limitations and usage recommendations, typical scenarios for memcached, unsuitable for use with memcached scenes; memcached Bulk Import Export
67th Lesson: Analyze exactly what content is put into memcached inside to cache, memcached combine business function to develop
68th Lesson: Continuing the development and testing of memcached combined with business functions
69th Lesson: nginx+varnish+ Basic Business Functions +memcached combined with the development and use of basic performance testing, memcached monitoring and preliminary optimization
70th lesson: Existing systems, applying the memcached architecture, thinking about how the architecture evolves

-----------------------below is the ACTIVEMQ section------------------------------------------------------------------

71st Lesson: activemq Introduction, function and characteristics; message middleware; ACTIVEMQ installation and basic use; Messaging HelloWorld
72nd Lesson: JMS Basic Concepts, PTP and pub/sub domains, JMS message structures: Message headers, attributes, and message bodies
73rd lesson: JMS Reliability Mechanism, acknowledgement of message receipt, persistence, expiration, priority, temporary destination, persistent subscription to local transaction, etc.; PTP model; Pub/sub model
74th Lesson: JMS API Architecture, a basic step for JMS application development; code example non-persistent topic messaging; code example Persistent topic messaging
75th Lesson: How broker starts, embedded in Java to start broker, start broker with spring integration
76th lesson: ACTIVEMQ Combined with Spring development: Environment settings, spring Configuration, queue messaging, topic messaging; ACTIVEMQ combining spring development best practices and recommendations
77th lesson: Connecting to ACTIVEMQ,ACTIVEMQ supported transport protocols and configurations: TCP, NIO, UDP, VMS, SSL, HTTP/HTTPS, etc.
78th Lesson: Activemq message store persistence; kahadb way, Amq way, JDMC way, Memory way
79th Lesson: Starting multiple BROKER;ACTIVEMQ static network links on a single server; The basic principle of static networkconnector; Available properties for networkconnector configuration
80th Lesson: Demonstration in Static bridge, multi-threaded consumer access to the cluster, the imbalance of consumer messages;
81st Lesson: Understanding lost Messages This scenario, configuring and demonstrating message reflow functionality under a static cluster
82nd Lesson: Fault Tolerant Links, failover protocol, available configuration parameters; activemq Dynamic Network link: Multicast protocol multicast,discovery Protocol, peer protocol, fanout protocol
83rd Lesson: ACTIVEMQ cluster: Queue consumer cluster, broker cluster, Master Slave (based on shared storage, JDBC implementation, replication Leveldb)
84th Lesson: Destination Advanced Features: Wildcard, combo queue, Configure Startup destinations, delete inactive destinations, Destination Options
85th Lesson: Destination Advanced Features: Virtual destinations, virtual theme, Mirror queue, Per Destination policies
86th Lesson: Message Dispatch Advanced Features: Messaging Cursors (store-based, VMS, file-based), asynchronous send
87th Lesson: Message Dispatch Advanced Features: Dispatch policies (strict sequential distribution policy, polling distribution policy)
88th Lesson: Message Dispatch Advanced Features: Optimized acknowledgement, producer flow control
89th Lesson: Message Advanced Features: Message properties, advisory message, delay, and timed message delivery
90th Lesson: Message Advanced Features: Blob Messages, message transformation
91st Lesson: Consumer Advanced Features: exclusive consumer, consumer asynchronous distribution, priority, manage persistent subscribers, message groups
92nd Lesson: Consumer Advanced Features: Message selector, re-delivery policy, slow consumer processing
93rd lesson: monitoring and managing broker, integrating ACTIVEMQ and Tomcat
94th Lesson: When to use ACTIVEMQ, ACTIVEMQ optimization and usage recommendations
95th Lesson: Application ACTIVEMQ: Analysis of what functions to use ACTIVEMQ to assist the implementation, ACTIVEMQ combined with the development of business functions the first part
96th Lesson: ACTIVEMQ combined with the development of business functions the second part, and test the corresponding functions
97th lesson: ACTIVEMQ combined with the development of business functions the third part, and test the corresponding functions, and then upload to the server
98th Lesson: nginx+varnish+ Basic Business Function +MEMCACHED+ACTIVEMQ combination run test
99th Lesson: The basic performance test is divided into two kinds, one is nginx+varnish+ basic business function +memcached, the other is nginx+varnish+ basic business function +memcached+activemq
100th Lesson: Architecture After application of ACTIVEMQ, and evolution of system architecture in the future

-----------------------The following is the MongoDB section------------------------------------------------------------------

101th Lesson: Overview of this section of the course, MongoDB Introduction: What is, the pros and cons of NoSQL, the cap theorem and base principle, the characteristics of MongoDB
102th Lesson: MongoDB Installation and basic usage, MongoDB startup parameter description
103th Lesson: MongoDB Basic Concepts: Databases, collections, documents, _id, basic data types, etc.
104th Lesson: MongoDB Additions and deletions operation the first part
105th Lesson: MongoDB Additions and deletions operation Part Two
106th Lesson: MongoDB Query Operation Part I: Specify the keys to be returned, query by criteria, including multiple operators, regular expressions
107th Lesson: MongoDB Query Operation Part II: Querying arrays, querying inline documents, paging, sorting, cursors, stored procedures, etc.
108th session: Aggregation Framework Part I: Concepts, Pipeline operators ($match, $project, $group, $sort, $limit)
109th Lesson: Aggregation Framework Part II: Operational use of $group, $unwind, $sort, and the development and use of MapReduce
110th Lesson: Aggregation Framework Part III: More MapReduce optional keys, use of Aggregate command group
111th Session: Understanding the document storage mechanism of MongoDB
112th Lesson: MongoDB Index Part I: Create, modify, delete indexes, and analyze the impact of using indexes on queries
113th Lesson: MongoDB Index Part II: Hint, forced full table scan, unique index, composite index, index collection, etc.
114th Lesson: Capped collection: function, rationale, creation and use of the syntax; Gridfs storage file: function introduction, basic operation, Fundamentals
115th Lesson: The first part of MongoDB's replica set: Introduction to Replica sets, creation of replica sets, use of replica sets, RS functions, rs.status descriptions
116th Lesson: MongoDB Replica Set Part II: Modify replica Set configuration, determination of master node in replica set, member configuration options-election arbitrator, priority, hidden member, delayed backup node, CREATE index
117th Lesson: The Fundamentals of the MongoDB replica set: Operation Log Oplog, initializing synchronization steps, processing stale data, heartbeat, member status, rollback, etc.
118th Lesson: Management of MongoDB replica sets and MongoDB master-slave replication: Starting members in stand-alone mode, configuration of replica sets, creating larger replica sets, forcing reconfiguration, turning the primary node into a backup node, and so on; MongoDB master-slave replication
119th Lesson: MongoDB Shard Part I: Introduction to Sharding, sharding and replication, Mongos, configuring servers, starting Mongos processes, converting replica sets into shards
120th Lesson: MongoDB Shard Part II: Data Shards, a collection of specified shards, detailed examples of shards
121th Lesson: MongoDB Shard The third part: block, split block, equalizer, limit the size of the Shard, the impact of the cluster on the data, understand the allocation of MongoDB shard data-a fragmented multi-interval, etc.
122th Lesson: The chip key selection of the MongoDB Shard: The importance of the key selection, the chip key rules, several types of tablet keys: small cardinal chip key, ascending tab key, randomly distributed chip key, the chip key based on a business, and the suggestion of a good chip key
123th Lesson: Management of MongoDB shards: List all Shard, view shard information, view summary of cluster information, check configuration information, delete shards, etc.
124th Lesson: Monitoring Application Status: View ongoing operations, System Analyzer system.profile; user authentication;
125th session: Backup and recovery, and data import and export
126th Lesson: Java Operation MongoDB: Get driver, connect MongoDB service, connection pool configuration, Operation MongoDB
127th Lesson: MongoDB and Spring integrated development: a CRUD that integrates, uses mongotemplate to perform data
128th Session: MongoDB application recommendations and best practices
129th Lesson: Analyzing the functions of MongoDB, MongoDB combined to the application of the development to achieve a
130th lesson: MongoDB Combined to application development implementation two, and upload server test
131th Lesson: Architecture Changes after applying MONGODB, continuous changes in the future architecture

-----------------------below is the mogilefs section------------------------------------------------------------------

132th Lesson: mogilefs Introduction, what, what, can do, and the characteristics and applicability;
133th Lesson: Installing mogilefs through the source code, basic configuration, etc.
134th Lesson: Understanding the basic concepts of mogilefs, how to use and various commands
135th session: Understanding MogileFS, including: high-level processes, storage nodes, table descriptions
136th session: MogileFS Java client development, including: Basic Java Client Development, and spring integrated development
137th Lesson: An example of a small application based on MogileFS Part one: Building the entire project development environment and preparation
138th Lesson: Examples of small applications based on MogileFS Part II: Use X-gen to generate new modules and debug functionality through CRUD
139th Lesson: Examples of small applications based on MogileFS Part III: Using Spring Web MVC for uploading and downloading files
140th Lesson: Small application based on MogileFS Part IV: Save the uploaded file to the mogilefs, and get the file from the inside
141th session: Integration of MogileFS and nginx, integration of MogileFS and memcached
142th lesson: After applying mogilefs, changes in system architecture, as well as more files, more frequent access, changes in architecture

-----------------------The following is the final summary of the phase and the overall deployment part------------------------------------------------------------------

143th Lesson: Stage One summary, Phase one build basic architecture, deployment environment Introduction and deployment plan
144th Lesson: Finishing the code and configuration of phase one, putting the entire project into a war that can be deployed and publishing it to the server
145th Lesson: Configuring the server-side nginx and varnish, configuring MogileFS, and testing through
146th Lesson: Configure Memcached and MongoDB, and test run through
147th Lesson: Configuring ACTIVEMQ and calling through the Web App, test run through
148th Lesson: The direction of development after phase one, and the evolution of the whole system architecture in the case of higher concurrency and greater data volume

....... Over, the main course is produced and released on time!


Online Java advanced Software Architect training Stage One

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.