Lots of information.
Matthew Wise - Matthew Wise
Java培训
Java培训，Java Programming Language
客户评论
其他课程类别
Java大纲
| 代码 | 名字 | 期限 | 概览 |
|---|---|---|---|
| 3627 | Introduction to Programming | 35小时 | The purpose of the training is to provide a basis for programming from the ground up to the general syntax of programming paradigms. The training is supported by examples based on programming languages such as C, Java, Python, Scala, C #, Closure and JavaScript. During the training, participants gain a general understanding of both the programming patterns, best practices, commonly used design and review of the implementation of these topics through various platforms. Each of the issues discussed during the course are illustrated with examples of both the most basic and more advanced and based on real problems. Introduction What is programming and why should devote his attention History of programming Opportunity to automate tasks using the software The role of the programmer and the computer in the enterprise Programming today the development of the current market trends Declarative and imperative programming. How or What? Turing machine Consolidation, compilation and interpretation "on the fly". Reminder issues of logic and Boolean algebra predicates logical sentences tautologies Boolean algebra The first program structurally functionally object And how else? Simple types Representation of strings Integers Floating-point numbers Boolean Type Null A blank or Uninitialized Strong and weak typing Data structures Concepts FIFO and FILO Stacks Queues Declaring arrays and lists Indexing Maps Records Trees Operators Assignment Operators. Arithmetic operators. comparison Operators And a comparison of the values in different languages Bitwise Concatenation Increment and decrement operators The most common errors Controlling the program The if, if else instructions Goto instructions, discuss the problems of application. The switch The for loop, for-in The while loop, do-while foreach loop Stopping loop Creating a reusable code Functional Programming Object-Oriented Programming Functional programming paradigms What is the function of Function and procedure Fundamentals of lambda calculus Function Arguments Returning values Functions as arguments Anonymous functions Closures Recursion The paradigms of object-oriented programming Representation of entities from the real world entities in philosophy, ontology Deciding what you want to object, or other types of Declaration of classes Creating instances of classes Fields, a state of the object Methods, as the behavior of an object abstraction Encapsulation Inheritance polymorphism Association and aggregation Delegation and separation of relationships between objects Modules, packages and libraries Sharing API The modeling of the system as classes and objects Describing and programming relationships between classes Program from a business perspective Good programming practice Pitfalls and common errors High-level code in the interpretation of low-level Code optimization KISS principle DRY principle Principle Worse is Better Separation abstraction of implementation Methods of error detection logic programs Conventions godowania Commenting the code Software Metrics Overview of these technologies and languages The area of application of these languages The main features of language Prospects for development The future direction of development: algorithmic, optimization of code, implementing patterns, design patterns, architectural patterns, analytical standards Reduction of the control structure - the use of artificial intelligence and automated decision-making Which platform to choose? Individual consultations |
| springcloud | Spring Cloud: Building microservices with Spring Cloud | 14小时 | Spring Cloud builds on Spring Boot to enable the development of distributed systems and microservices. In this training we start with a discussion of microservice architecture. Participant knowledge is put to the test through exercises and the step-by-step development of sample microservices. By the end of this training participants will have a solid understanding of how to use Spring Cloud and related Spring technologies to rapidly develop their own cloud-scale, cloud-ready microservices. Audience Java developers wishing to rapidly build and deploy microservices Format of the course Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development. Introduction Microservice architecture, PaaS, and cloud-native design Overview of Spring Cloud sub-projects Config Server & Bus, Eureka, Ribbon, Feign, and Hystrix Overview of Spring Boot Setting up your development environment Creating a Spring Boot application Centralized, versioned configuration management with Spring Cloud Config Dynamic configuration updates with Spring Cloud Bus Service discovery with Eureka Load balancing with Ribbon Applying circuit breakers with Hystrix Declarative REST clients with Feign Working with API Gateway Securing your microservices Tracing microservices to uncover latencies Troubleshooting Closing remarks |
| qaci | Quality Assurance and Continuous Integration | 14小时 | Training is open to both developers, Scrum Masters, Product Owner and also some aspects of the business department. The purpose of training is to introduce topics Quality Assurance and Continuous Integration and their place in projects conducted agile methodologies. Participants will gain a broad perspective on the issues discussed as well as practical knowledge of the tools and processes of software development in line with the QA / CI. Representatives of business, will be able to know the benefits of implementing those tools and processes and translate into both the time and cost of software development. The issues presented are based on PHP or Java, depending on customer requirements. QA/CI What is QA? What is CI? The costs of software development, refactoring and fix errors Identifying and understanding the project Profit for the organization DDD Software development based on business requirements, assumptions DDD Problems in communication IT-Business Domain Model Best Practices KISS principle and DRY Coding standards Creating reusable code through OOP and design patterns Identifying and reducing cyclomatic complexity Software Metrics Weight Method per Class Response For a Class Depth of Inheritance Tree Coupling Between Objects Lack of Cohesion of Methods Number of Children Cyclomatic complexity Metrics class Model Metrics Metrics for use Software Testing What, when and how to test? The method of "white-box" and "black box" The role of testing in agile methodologies TDD only a potential increase in the cost of the project Unit testing with JUnit (Java), PHPUnit (PHP) Behavioral tests of JBehave (Java), Behat and Mink (PHP) Functional tests Refactoring What is refactoring? Debt technology Code smell Refactoring patterns Documentation The role of documentation in agile methodologies What to document? Types of documentation Documentation and agile methodologies, or you can call (Working software over comprehensive documentation)? Standard XMI Automatic generation of documentation from the Javadoc (Java), ApiGen (PHP) Tools and Environment CI Tools and Environment CI PMD (Java), phpmd (PHP) CPD (Java), phpcpd (PHP) Lines Of Code Counter (Java), phploc (PHP) UCDetector (Java), phpdcd (PHP) Jdepend (Java), phpdepend (PHP) Jenkins Continuous Integration Server Agile and CI/QA Planning and incremental development Embracing Change Short stages Interdisciplinary team Extreme Programming, Code Review Individuals and interactions over processes and tools Summation Discussion Questions How do you begin the process of implementation? |
| javatesting | Introduction to Java for test automation | 28小时 | This course is designed for anyone interested in learning Java for the purpose of test automation. It is a streamlined, intensive course with plenty of hands-on exercises to get participants ramped up quickly with the essential programming skills needed to apply to software automation testing. The focus is on the Java fundamentals which can be directly and immediately applied to test automation. This course does not cover in depth test automation frameworks such as Selenium. It also bypasses the conventional "Hello World" approach to learning Java, as this is not a course on application development. This course is squarely aimed at getting participants up and running quickly with test automation. If you are already versed in Java and wish to get straight into testing with Selenium, please check out: Introduction to Selenium (https://www.nobleprog.com/introduction-selenium-training). Audience Beginner testers who wish to learn Java for automation testing Professional testers with experience in other programming language such as Javascript and C# who wish to transfer their skills to Java. Format of the course Part lecture, part discussion, heavy hands-on practice Introduction Installation and setup Java programming - getting started Overview of JUnit Writing your first Unit test Understanding JUnit assertions JUnit annotations (@Test) Java methods as @Test methods Using and creating Java classes Importing packages Java data types and operators Implementing conditions and loops in your test script Understanding Java arrays Other ways to iterate through your code Catching and throwing exceptions Understanding Java inheritance Handling exceptions Manipulating strings Working with numbers Working with dates and times Java Property files Reading and writing files Logging Using abstract classes Using regular expressions Closing remarks |
| restapi | REST API - a pattern of exchange of information between sites | 14小时 | The course is designed for developers, web applications, aims to provide opportunities offered by the REST architectural pattern by which you can communicate between sites. REST - base The need for the exchange of information between sites HTTP POST / GET / PUT / DELETE Services such MushUp and popular applications Services using REST Conventions Rest Mapping CRUD operations on HTTP calls Conventions API URL structure Passing Parameters Return Values HTTP statuses JSON - a universal format for the exchange of information API services Examples of the popular API RESTful frameworks Create a REST API - Server Gathering requirements and identify functionality Design and API documentation Installing the required libraries Business Object - mapping the class Controller methods Representation of a business object as JSON HTTP Headers - as metadata Testing the API using cURL Authentication mechanisms |
| jetty | Jetty: Embedding a web server inside your application | 7小时 | Enterprise Java development does not need to be heavyweight and Ant-driven. Learn to bypass the complexity of setting up and maintaining a standalone web container. Instead learn how to embed the web server into your application with embedded Jetty. "Don’t deploy your application in Jetty, deploy Jetty in your application!" Some of the topics covered in this instructor-led, live training include: Instantiating Jetty as a POJO (Plain Old Java Object) Replacing Tomcat with Jetty for Spring Boot integration Automatically deploying embedded Jetty with Maven Request this course now! Audience Developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Request a custom course outline now! |
| gfadm | GlassFish Administration | 21小时 | GlassFish Administration Training introduces participants to the secrets of the installation, configuration, management, monitoring GlassFish server. Training is open to future GlassFish server administrators. Introduction and Installation GlassFish Overview and architecture of Java EE GlassFish White Basic GlassFish Architecture Download and install GlassFish Starting and Stopping the GlassFish Structure and architecture File structure Server profiles, domains, and configuration Configuration Files - Setup.xml and domain.xml Login and login configuration The Admin Console The asadmin Command Line Interface Deployment The structure of the Java EE Application (Jars, Wars, Ears, Sars) GlassFish Deployment Details Deploying with the Admin Console and asadmin Deploying Using autodeploy Deploying with asant Tasks Directory (Expanded) Deployments GlassFish Classloading, and Effect on Deployment Configuration Services (Web, JNDI, Datasource, EJB, Web Service) Web Container Overview Configuring the Web Container / HTTP Service Virtual Hosts and Listeners JNDI and Naming Overview Configuration GlassFish Naming Configuration klienta JNDI Review DataSource i JCA Configuration DataSource i Connection Pool Container EJB EJB Pooling and Caching Container Management EJB Web Service Overview and Deployment Viewing, Monitoring, and Managing Web Services Messaging JMS - Java Message Service Overview GlassFish Messaging Overview - Sun Message Queue Creating Connection Factories and Destinations (Queue/Topic) Configuring the JMS Provider Safety Overview Java security EE GlassFish Security Architecture Manage Users, Groups file, JDBC, LDAP, and other Realms Password security - password encryption, Master and adminstracja password SSL / TLS and HTTPS Overview Configuring and Using GlassFish keytool Security other sites Monitoring and Tuning GlassFish Monitoring Tuning Clustering GlassFish Clustering Overview Cluster Configuration The Repository, Cluster Instances, and the DAS Clustering Architecture (Client Interceptor, Load Balancing and Fault Tolerance, State Replication) Clustered Services Load Balancers and Clustered Http Configuring Apache httpd for Use with the Load Balancer Conclusions |
| scalaadvanced | Scala: Advanced object-functional programming | 14小时 | Scala is a concise, object-oriented language with functional programming features, including currying, type inference, immutability, lazy evaluation, and pattern matching. Scala code runs on a JVM and was designed to address some of the shortcomings of Java. In this instructor-led, live training participants will learn how to use Scala's advanced features, including its type system, to write better code using an object-functional approach. By the end of this training, participants will be able to: Leverage Scala's type system to maximum benefit Handle exceptions functionally Create libraries and DSLs with Scala Use Scala's advanced features for pattern matching Audience Scala programmers who wish to learn the more advanced and nuanced features of Scala Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Introduction Scala as a JVM language Objection-oriented programming vs functional programming Overview of object-functional programming Tail recursion Partial functions Currying and partial function application Closures Lazy evaluation Mastering the Scala type system About traits Structural types Path dependent types Self types Covariance and contravariance Type bounds Advanced pattern matching in Scala Deep matching Using extractors Using Scala Implicit Implicit conversion, classes and parameters Type class pattern Context and view bounds Libraries and DSLs Custom control structures with by-name parameters Building well-designed libraries and internal DSLs Working with Scala collections Working with Streams Manifests and class tags Builders CanBuildFrom Building custom collections Functional exception handling Traditional exception handling Functional exception handling Using Try with For comprehensions Closing remarks |
| junit | Unit Testing with JUnit | 21小时 | JUnit jumpstart Proving it works Starting from scratch Understanding unit testing frameworks Setting up JUnit Testing with JUnit Exploring JUnit Exploring core JUnit Launching tests with test runners Composing tests with TestSuite Collecting parameters with TestResult Observing results with TestListener Working with TestCase Stepping through TestCalculator Sampling JUnit Introducing the controller component Let's test it! Testing exception-handling Setting up a project for testing Examining software tests Why we need unit tests Kinds of tests Determining how good tests are Test-driven development Automating JUnit A day in the life Running tests from Ant Running tests from Maven Running tests from Eclipse Coarse-grained testing with stubs Introducing Stubs Practicing on an HTTP Connection sample Stubbing the web server's resources Stubbing the connection Testing in isolation with mock objects Introducing mock objects Mock tasting's simple example Using mock objects as a refactoring technique Practicing on a HTTP connection sample Using mocks as Trojan horses Deciding when to use mock objects In-container testing with Cactus The problem with unit-testing components Testing components using mock objects Integration unit tests Introducing Cactus Testing components using Cactus How Cactus works Unit-testing servlets and filters Presenting the Administration application Writing servlet tests with Cactus Testing servlets with mock objects Writing filter tests with Cactus When to use Cactus, and when to use mock objects Unit-testing JSPs and taglibs Revisiting the Administration application JSP unit testing Unit-testing a JSP in isolation with Cactus Unit-testing taglibs with Cactus Unit-testing taglibs with mock objects When to use mock objects, and when to use Cactus Unit-testing database applications Database unit testing Testing business logic in isolation from the database Testing persistence code in isolation from the database Writing database integration unit tests Running the Cactus test using Ant Tuning for build performance Overall database unit-testing strategy Unit-testing EJBs Defining a sample EJB application Using a fa?ade strategy Unit testing JNDI code using mock objects Unit-testing session beans Using mock objects to test message-driven beans Using mock objects to test entity beans Choosing the right mock object strategy Using integration unit tests Using JUnit and remote calls Using Cactus |
| scalaadvancedfunctional | Scala: Advanced functional programming | 14小时 | Scala is a concise, object-oriented language with functional programming features, including currying, type inference, immutability, lazy evaluation, and pattern matching. In this instructor-led, live training participants will learn how to use Scala's advanced features to develop well-constructed software that is easy to write, read, test, and change. The focus of this training is on functional programming, using real-world case studies and discussion as a reference for lab exercises and activities. By the end of this training, participants will be able to: Implement advanced functional programming techniques Make sense of complex type signatures Understand code through types and substitution Handle exceptions functionally Create libraries and DSLs with Scala Use Scala's advanced features for pattern matching Audience Scala programmers who wish to learn the more advanced and nuanced features of Scala Format of the course Part lecture, part discussion, exercises and heavy hands-on practice Introduction Who uses Scala? Developing large-scale, purely-functional programs Overview of functional programming in Scala Higher-Order Functions Combinators Polymorphic Functions Mastering Scala Types Product types & Sum types Supertypes & Subtypes Universals & Existentials Higher-Kinded Types Type Lambdas Mastering Scala Type Classes Classes & Instances Tricks with Implicits Polymorphic Constraints Case study: Highly-stateful programs with complex external systems Coding exercise Working with Data Immutable Data & Recursion Catamorphisms & Church Encoding Fixed-Point Data Recursion Schemes Advanced pattern matching in Scala Deep matching Using extractors Case study: Scala and Big Data Coding exercise Using Functional Patterns Options, Eithers & Validations Semigroups & Monoids Functors Applicatives Monads Foldables & Traversables Lenses Working with Effects IO State Reader Combining Effects Case study TBD Coding exercise Functional Architecture Modern Architecture for FP Reified Computation & Deferred Evaluation Compositional Evaluators Optimization Techniques Purely Functional Mocking Libraries and DSLs Custom control structures with by-name parameters Building well-designed libraries and internal DSLs Functional exception handling Traditional exception handling Functional exception handling Using Try with For comprehensions Final coding exercise and evaluation Closing remarks |
| javafun | Java Fundamentals | 28小时 | The course covers the basics of Java development. It introduces students to Java technology and teaches them basic Java syntax and concepts, leading to the creation of a simple program. Training goes through the essential concepts and features of the Java Programming Language, focusing on exceptions, basic input/output, concurrency, regular expressions, Java collections framework and the platform environment. The course finishes when all basic Java features have been explained and trained. Getting Started The Java Technology Phenomenon How to write basic "hello world" application How to compile and execute Java code How to make the code a bit more complex Java Syntax Object-Oriented Programming Concepts Variables, arrays, data types, operators, and control flow What are reference variables Classes and objects What inheritance is and how it works What Interfaces are, why they are written and how How to use Java String and Number objects and how to format data for output What packages are for and why we must use import directive Java Objects Java classes overview Java class life cycle Class modifiers and inheritance Overloading" and overriding Class constructors Polymorphism Relationships: IS and HAS 'static' keyword When to use static members Java Collections Collection interface Lists, maps and sets Collections and arrays Concurrency Java Memory Garbage collector Heap and stack Object life cycle 'finalize()' method Java Exceptions The general idea of Java Exceptions Runtime and 'real' exceptions Throwing an exception 'try...catch' statements 'throws' declaration Designing your own exceptions Java Concurrency Threads and concurrency Threaded tasks Joining threads Class variables visibility |
| javah | Java Hibernate | 28小时 | Introduction to the issue of transaction and sustainability components (Optional) Introduction to transaction management in web applications and in particular in the context of Java EE The introduction of the architecture of the transaction and transaction manager and then transition to the idea of a light framework of transaction management and data durability Hibernate Architecture Overview of the most important elements and the idea behind PHP framework Hibernate Discussion of how to implement a mechanism to hide component life through the implementation of the framework and to hide the drivers and as the database itself How is used for communication with the database via Hibernate? Hibernate in Action Example of use Hibernate framework in a simple Spring web application that requires consolidation of object Introduction to the theme of the DAO - their interfaces and implementations Mapping tables on POJO class The use of POJOs as realizing the idea of entity objects within a web application The use of declarative mechanisms mapping database table rows to objects POJO Creating relationships between objects Discussion of the implementation of the transfer relation strictly object model database using Hibernate framework Transactions in Hibernate Discussion of the transaction abstraction within the Hibernate framework, defining global and regional transaction and define their level. Hibernate Query Language (OPTIONAL 1day) Discussion of the high-level abstraction definition language database queries within the framework Hibernate Connection example Spring MVC application with Hibernate mechanism On this example application will be shown how to combine the two frameworks of integration within the web application |
| gwt | GWT: Write Ajax web applications in Java, deploy as Javascript | 28小时 | Google Web Toolkit (GWT or GWT Web Toolkit) is a set of open-source tools for building, optimizing and maintaining complex JavaScript browser-based applications in Java. GWT is used by many products at Google, including Google AdWords and Google Wallet. In this instructor-led, live training, participants will learn the GWT programming concepts needed to get a web application up and running. By the end of this training, participants will be able to Write client-side AJAX applications in Java and deploy them as JavaScript across multiple browsers (desktop, Android, iPhone, etc.) Develop a high-performance web application while overcoming the idiosyncrasies of browser behavior, XMLHttpRequest, and JavaScript Understand and overcome the challenges of Ajax programming Use GWT's tools to optimize a web application Audience Front-end web developers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us. |
| javaeejboss | Enterprise Java Programming with Java EE and JBoss (EJB 3.0) | 28小时 | This 4-day course is for programmers who already know the Java language and wish to exploit the Enterprise Java Beans 2.0 technology while becoming aware of the security implications of distributing applications. This course has a large practical component which includes developing an e-commerce application based on Enterprise Java Beans. The course uses the JBoss Application Server. Enterprise Java Programming From client-server to 3-tier architecture Design considerations Security considerations Naming Services Comparison of RMI, CORBA and EJB Java Naming and Directory Interface (JNDI) JNDI Architecture Service Providers and the Service Provider Interface The Initial Naming Context Looking up objects Creating, searching and destroying directory entries Exercise 1: JNDI File Search Introducing Enterprise Java Beans (EJB) EJB concepts and versions Component Transaction Monitors Commercial implementations The EJB Architecture Persistence and transactions Java EE and EJB Deployment The JEE environment and tools Configuring Java EE JEE and JNDI Naming EJB packaging and deployment The deployment tool The Hypersonic Database Exercise 2: Set up JBoss EJB Clients Types of client Java clients Web and JSP clients Servlets and WAR files Exercise 3: Write and Deploy a Servlet Client JPA The role of an JPA Configuring an JPA Exercise 4: JPA/li> Stateless Session Beans The roles of Session Beans Creating Session Beans Stateless Session Beans Exercise 6: Stateless Session Bean Stateful Session Beans Stateful Session Beans Exercise 7: Stateful Session Bean EJB Implementation Issues Meta data Transaction management 1-1, 1-many, many-1 and many-many associations EJB versions The Java Messaging System The Java Messaging System (JMS) Exercise 8: JMS Security Users and roles Access control Authentication Exercise 9: JBoss Security Message Driven Beans The Message Driven Enterprise Bean Exercise 10: Message Driven Bean |
| javaspring | Java Spring | 35小时 | Oriented programming interfaces Modeling and programming based on the interfaces idea Problems solved by the programming-oriented interfaces Component-oriented programming The role of the components in the web application model, the introduction of the concept of POJO objects as objects performing the function of the components in the web application Design Pattern Inversion of Control and Dependency Injection Pattern of inversion Control and its variants Dependency Injection, IoC container Declarative as dependencies between the components of a web application Architectural Overview Spring Spring application context-a and its role as an IoC container. How to realize the function of an application framework? Where begins the life cycle of a web application based on Spring? Is it possible to use the Spring IoC container in your application not necessarily site? The configuration files Dependency Injection declaratively through XML files that define how the creation and application components imparting The dependencies between components File format description of the components and examples of Spring dependency injection Factory components and its use Mapping the components defined in the description file dependency injection and how to implement the injection mechanism by Spring plant components Distinction between the components of a singleton and prototype Component life cycle and identification of components Component life cycle Component identification Programming in Spring AOP Aspect-Oriented Programming (Aspect Oriented Programming) Declarative mapping application aspects in the design and definition of the intersection points Introduction to Spring AOP and application examples MVC Spring-a Discussion of abstraction controllers and views Spring Framework and examples of applications most of them. Introduction to the idea of the model, view and controller Spring applications Create an application using Spring MVC Standard controllers and managers view the Spring web application Wiring properties model with a view and vice versa Introduction to the issue of trade and sustainability components Transaction management (especially Java EE) Transaction manager Light framework and persistence Spring transaction management mechanism Light Spring Framework transaction manager Spring mechanisms for managing transactions Mapping of table rows for POJO objects using Spring Use of data access methods Spring Framework to create database queries To define the data access Create Data Access Objects (DAO) Implementation and use DAO to stabilize application components |
| OpenSearchServer | OpenSearchServer | 7小时 | OpenSearchServer is an open-source application server used to develop index-based applications such as search engines. Written in Java, it can be integrated into other applications without using Java code. In this instructor-led, live training, participants will learn set up, configure, manage and extend OpenSearchServer. By the end of this training, participants will be able to: Run OpenSearchServer as a standalone server with a servlet container Configure OpenSearchServer's integrated crawler for databases, web pages and rich documents Develop a sample application using OpenSearchServer's Zkoss-based web UI Integrate search results into a page using the HTML renderer Monitor and administer OpenSearchServer Extend OpenSearchServer's features using its plugin architecture Audience System administrators DevOps engineers Format of the course Part lecture, part discussion, exercises and heavy hands-on practice To request a customized course outline for this training, please contact us. |
| javaph | Java Persistence with Hibernate | 14小时 | This course teaches the practical use of Hibernate for persisting Java objects in a relational database. Introduction to Hibernate Introducing Hibernate The Object/Relational Mapping Problem JDBC The Users-Roles Schema Tools and Environment Setup Creating the Database Configuring Hibernate Hibernate Distributions Required Libraries Configuration Files hibernate.properties hibernate.cfg.xml Hibernate Persistence The Hibernate Architecture SessionFactory Methods Hibernate Sessions Object States State Transitions Session Methods Transactions Session-Per-Operation Session-Per-Request The Data Access Object Pattern Object/Relational Mapping Object-Oriented Design Relational Mapping Bidirectional Association O/R Mapping Techniques The Mapping Document The Mapping XML Model Primary Keys and Identity Generating Identifiers Other Mapping Elements Components Mapping Associations The Mapping XML Model for Associations Unidirectional Many-to-One Eager Fetching Bidirectional One-To-Many Bidirectional One-To-One Mapping Inheritance Inheritance and Databases Single-Table Inheritance Mapping Single-Table Inheritance Table-Per-Subclass Table-Per-Subclass Mapping Table-Per-Concrete-Class The Hibernate Query Language The Hibernate Query Language Fundamentals HQL Queries Polymorphism Named Parameters Entity Parameters Joining on Associations Aggregate Methods Updates and Deletes Named Queries Using Native SQL |
| dsgpat | Design Patterns - efficient code reusability | 21小时 | The course will cover the design patterns. We provide design patterns trainings divided in two groups: Core patterns include (selected patterns from GoF package) some basic design patterns used throughout all modern applications and systems. They significantly increase productivity and decrease complexity of these applications introducing ready and checked ways to accomplish certain functionalities. Creational patterns: Builder Factory Prototype Singleton Structural patterns: Delegator Interface Facade Composite Immutable Adapter Decorator Activity patterns: Interpreter Command Template method Observer Proxy Java EE Patterns include (SUN Microsystems selected patterns). This selection of patterns helps to build and maintain complex and huge Java EE based projects. Following design patterns simplify design via introduction of multi-tier application design and well controlled responsibility flow. View tier patterns: Intercepting filter Front controller Application controller View helper Composite view Dispatcher view Business tier patterns: Business delegate Service locator Session facade Application service Business object Value object Integration tier patterns: Data Access Object Service activator Web service broker |
| javaperf | Java Performance | 35小时 | What will you learn? Performance tips all come with a shelf life that is linked to the particular technology to which they are applied. Once that technology changes or is no longer used, the tips become useless at best and harmful at worst. For this reason we have purposely designed a course that focuses on providing you with something more than just tricks to get the latest and greatest framework to meet your performance needs. One of the tools we aim to leave you with is a methodology that we've used over the years on a regular basis. This methodology has helped us quickly identify and solve hard performance issues. The other equally important aspect of performance tuning is tooling. A good portion of the course focuses on a number of open source tools that we have found to be useful in our campaigns to stamp out performance bottlenecks. Beyond methodology and tooling, we look at some of the fundamentals of Java technology. This includes the inner workings of the Java memory management and HotSpot/JIT technologies. Objectives how to apply rigor to the task of performance tuning how to setup a performance tuning environment importance of performance tuning requirements and goals tools needed to conduct a performance investigation benchmarking and micro-benchmarking skills Java memory and execution models Tools & Methodology Defining performance and performance tuning Common performance problems Profiling, and monitoring with professional tools Execution, memory and thread profilers System level monitoring Java Management eXtentions Architecture Planning for performance Patterns and anti-patterns Messaging Architectures for performance Coding Best Practices Big gains user perceptions Macro and micro benchmarking Selected Java Libraries including String, I/O and Collections XML parsing Serialization Concurrency Memory Management Java Virtual Machine heap spaces Garbage collection algorithms Object life-cycle Garbage collection logging and monitoring Heap tuning strategies |
| javaappsh | Spring and Hibernate in Java Applications | 21小时 | The course covers issues related to the creation of Java applications with particular emphasis on technology widely used today in applications such as application frameworks for building Spring and Hibernate. The participants at the end will have knowledge to design applications and to select the appropriate technology for a specific solution. Enable understanding of known issues discussed in the course of libraries, specifications and technologies. Component-oriented programming Design Pattern Inversion of Control and Dependency Injection Architectural Overview Spring Spring Application Context Configuration files Mapping objects Factory components and its use Programming in Spring AOP The use of new technologies in the Spring MVC Spring Create an application using Spring MVC Combining Spring MVC with Java Server Faces Introduction to Hibernate Architecture/Structure The life cycle of objects and identify objects Hibernate in Action Mapping tables on POJO category Construction of POJO category Mapping properties of the columns in the tables Establishing relationships between objects Transactions in Hibernate Local and global transactions Overview of API transactions Levels of transaction Language HQL - Hibernate Query Language Combining Hibernate and Spring applications |
| struts2 | Struts 2 Framework | 21小时 | This course deals with developing MVC (Model-View-Controller) web application using the features of Struts2 framework. The participants will learn how to work with the actions and the data, how to develop interceptors and the OGNL for type conversion. This course will also cover concepts like validation, internationalization and how to persist data. Introduction to Struts2 Web applications: a quick study Why use a framework for web applications The Struts2 framework and the declarative architecture The support of annotations Actions and Interceptors The role of actions Implementing and packaging actions How to dialogue with data The role of interceptors Developing and declaring interceptors The request/response life cycle OGNL (Object-Graph Navigation Language) The common tasks in a web application Data transfer and type conversion The built-in converters How to build a custom type converter How to validate data The validation framework Using the built-in rules Writing a custom validator Writing the actions for validation Internationalization Java i18n and Struts2 framework How to use Struts2 i18n The default local determination Struts2 integration and the persistence layer Using Spring with Struts2 The concept of injection Why use the JPA with Struts2 Integrating Struts2 with Hibernate |
| java8spring | Java 8 and Spring | 35小时 | This 5 day course is for Java developers who wish to gain familiarity with the new features of Java 8 and with the Spring framework. Java 8 Lambdas Predicate Generics revisited Optional Streams Date and time API Spring Framework OO principles Inversion of Control Spring ApplicationContext BeanFactory XML configuration files Dependency Injection Why dependency injection? Injection through setters Injection through constructors Setters versus constructors Spring JDBC DAO design pattern POJO to database mapping Database queries Spring MVC MVC design pattern DispatcherServlet Controllers Models JSPs Spring Validation Validation mechanisms Displaying error messages |
| javafunandroid | Java Fundamentals for Android | 14小时 | Applications for the Android platform are developed primarily in Java. This course was developed for software programmers with a strong OOP background (whether in PHP, Scala, C++, C# or Objective C) that plan to learn how to develop Java applications for the android platform. This course covers the Java programming language grammar and focuses on those specific Java capabilities the android platform uses more than others. Let's Start History JVM JDK JRE Hello World JavaDoc Classes & Packages API Documentation The Basic Java comparing with C++ Simple Output Remarks Native Data Types Variables Keywords Identifiers Expressions & Operators Simple & Compound Statements Control Statements Looping Statements Assignments Local Variables Assertion Annotations Introduction to OOP Software Development Cycle Objects & Classes Key Features of OOP Relationships between Objects Object Oriented Programming Objects Classes & Class Type Variables Declaring Classes, Class Type Variables Calling a Method The 'this' Special Keyword Class Declaration Declaring Attributes Declaring Methods Methods Overloading Declaring Constructors Default Constructors Overloading Constructors Using 'this' within Constructors Static Variables Static Methods Static Initializers Final Variables Software Packages Package Statement The 'import' Statement Declaring Enums Java API Documentation Arrays & Strings Array of Native Type Values Array of Objects Square Brackets Position Copying Array Values Multi Dimensional Array The 'length' Variable The 'String' Class Instantiating String Comparing Strings The 'toString()' Method The StringBuffer Class The StringBuilder Class The StringTokenizer Class Passing Arguments to 'main' Method Inheritance Introduction to Inheritance Inheritance in Java Derivation Syntax Inheritance Meaning Constructors & Inheritance Access Modifiers Overriding Methods Polymorphism Constructors & 'super' Keyword Abstract Class Interfaces The 'instanceof' Operator Casting References Deprecated Methods The 'object' Class Inner Classes Inner Classes Types In-Depth Meaning Inner Classes within Methods Anonymous Inner Class Static Inner Class Exceptions Handling The Exceptions Handling Mechanism Exceptions Classes Hierarchy Three Types of Exceptions Try&Catch Statement The 'throw' Command The Throwing Chain The 'finally' Block The 'throws' Adding The 'Handle or Declare' Rule Methods Overloading, Samples Threads Basics What is a Thread? The Thread Parts Creating New Thread Starting The Thread Multiple Threads I/O Streams Java I/O Overview I/O Streams Categories Byte & Char Streams The InputStream Abstract Class The OutputStream Abstract Class Writing/Reading To/From Files Generics Introduction Subtypes Wildcards Collections Introduction Performance Set List Queue Map |
| javaadvanced | Java Advanced - one day | 7小时 | Introduces contect for Advanced java programmers, usually developing large scale applications, frameworks or libraries. This course is mostly labs (around 60%), the rest is discussions and presentation. We mostly use the newest version of Java for this course, but it can also be delivered as a private course on older versions of Java.Generics Why, when and benefit/cost of Genercis Type Erasure Type Boundaries Wildcards Generic Methods Multithreading Java Thread System Managing Threads Interacting with Threads and Thread State Thread Synchronization Volatile Fields and Synchronized Methods wait and notify pattern join and sleep pattern Concurrency API Atomic Operations Thread Pools Reflection When to use and when not to use reflection Uses for Meta-Data The Reflection API The Class<T> Class The java.lang.reflect Package Reading Type Information Navigating Inheritance Trees Dynamic Instantiation Dynamic Invocation Reflecting on Generics Accessing private fields using reflection Annotations Aspect-Oriented Programming (AOP) Built-In Annotations Annotations Model Annotation Types and Annotations Annotations vs. Descriptors (XML) Multi process communication Shared memory Socekts Non-Blocking Sockets TCP URL Objects HTTP and Other TCP Servers Datagram Clients and Servers Multi-Threading in Servers |
| jcapsdaadv | OpenESB-Java CAPS for developers and architects advanced level | 14小时 | This course is dedicated to developers and architects who want to be operational immediately on OpenESB and want to start and be involved on real OpenESB projects. The training scope covers the advanced OpenESB concepts frequently used in projects like correlation and compensation. This 2 day course will allow you to serenely tackle your integration in operational OpenESB projects. SOA development Process Introduction to service oriented development process Fault and exception management in BPEL Faults and Exception management in BPEL Faults, exceptions, Catch, Handlers Advanced concept and exercises BPEL Compensation Introduction to compensation in a BPEL process Advanced concept and exercises BPEL Correlation Introduction to Correlation in a BPEL process Advanced concept and exercises BPEL mapper advanced Features BPEL mapper advanced Features (Predicate, Java calls…) Transaction, Guarantee of delivery, consistency with OpenESB Advanced lecture on Guarantee of delivery consistency concept with OpenESB Exercises 50% of the time is dedicated to practical use cases and exercises |
| javaint | Java Intermediate - one day | 7小时 | Participants who are already Java programmers who want to extend their horizon and used more Java language concepts.Review Inheritance and Intefances Object References vs Inheritence Polymorphism Interface Static and Default Methods Collections and Generics Generics (Inheritance, Wildcards) Writing Generic Types Design Patterns Object Creation Static methods and fields new Operator Creation Patterns Inheritance vs Composition / Pros and Cons Composite Pattern Inner Classes Reflection The class called Class Finding Fields, Methods, and Constructors Accessing Fields, Invoking Methods Examining Arrays Annotations Annotations in the Java API (@Override, @Deprecated) Defining Annotations Functional Programming Lambda Expression Overview Lambda Expressions and Functional Interfaces Using Lambda Expressions Working with Method References The Stream API Streams and Collections Filtering Collections Chaining and Pipelining Date/Time API Legecy APIs The Date/Time API (JSR 310) Date-Based and Time-Based Events Timestamps, Periods, and Durations Performing Calculations Formatting Localization / Time Zones JUnit Basics JUnit Overview, Test Driven Development Tests and Assertions Working With Exceptions Organizing Tests with JUnit Writing Fixtures - @Before, @After Test Suites, and Other Capabilities Mock Objects Overview Build Tools Ant Overview Maven Overview |
| gfsjeeint | Administering GlassFish Server with Java EE applications introduction | 21小时 | Introduction to GlassFish Server Overview of the Java EE Architecture GlassFish Background GlassFish Basic Architecture GlassFish Basic Features Installing and upgrading Installation Upgrade Administering and deploying applications Administration High Availability Administration Security Application Deployment Message Queue Administration Troubleshooting Troubleshooting Error Message Scaling and tuning the performance Deployment Planning Performance Tuning Developing applications Your First Cup: An Introduction to the Java EE Platform The Java EE Tutorial Application Development Guide Message Queue Developer's Guide for Java Clients Message Queue Developer's Guide for JMX Clients Message Queue Developer's Guide for C Clients Extending and embedding Add-On Component Development Guide Embedded Server Guide |
| accumulo | Apache Accumulo: Building highly scalable big data applications | 21小时 | Apache Accumulo is a sorted, distributed key/value store that provides robust, scalable data storage and retrieval. It is based on the design of Google's BigTable and is powered by Apache Hadoop, Apache Zookeeper, and Apache Thrift. This courses covers the working principles behind Accumulo and walks participants through the development of a sample application on Apache Accumulo. Audience Application developers Software engineers Technical consultants Format of the course Part lecture, part discussion, hands-on development and implementation, occasional tests to gauge understanding Introduction Installing Accumulo Configuring Accumulo Understanding Accumulo's data model, architecture, and components Working with the shell Database operations Configuring your tables Accumulo iterators Developing an application in Accumulo Securing your application Reading and writing secondary indexes Working with Mapreduce, Spark, and Thrift Proxy Testing your application Troubleshooting Deploying your application Accumulo Administrative tasks |
| atomjeeadm | Apache Tomcat and Java EE Administration | 21小时 | Teaches attendees the fundamentals of administering Apache Tomcat and other Java EE environments. The course is a mixture of lectures and hands-on exercises. Delegates learn by doing, with immediate opportunities to apply the material they learn to real-world problems. Introduction to the Java Platform The JVM, JRE, and JDK Java SE versus EE Apache Tomcat as a lightweight servlet/JSP container, and how this differs from full-blown Java EE application servers such as WebLogic, WebSphere, JBoss, and GlassFish Architecture of Applications installed to Tomcat Understanding classes versus JARs Servlets JSPs JavaBeans JNDI and datasources Resources that your applications may call on other servers (web services, EJBs, etc.) Installing Tomcat Installing the Java Runtime Environment (JRE) Tweaking the JRE for performance Performing the actual Tomcat installation Examining the Tomcat installation directories bin conf lib logs temp webapps work Configuring Tomcat server.xml (detailed walkthrough) web.xml context.xml Deploying Java EE Applications Packaging JARs for deployment to Tomcat Packaging WARs for deployment to Tomcat Application server-neutral configuration versus application server-specific configuration Overview of EARs and other archive types not supported by Tomcat, but supported by other Java EE application servers Versioning Java EE applications Managing the deployment of updated applications Tomcat Valves AccessLog and FastCommonAccessLog RequestFilterValve SingleSignOnValve (by request) RequestDumperValve (by request) Memory management and JMX monitoring Understanding Java garbage collection Using JAVA_OPTS, JMX and JConsole to monitor and tune Tomcat memory usage Sizing Tomcat's JVM memory heap Using JMX and JConsole to configure Tomcat via Tomcat's MBeans Updating Tomcat's configuration via JMX "on the fly" without restarting Tomcat Load testing with JMeter Using VisualVM (new monitoring tool built into JDK 6) and PSI Probe Controlling JMX MBeans via Ant Logging and Troubleshooting JULI logging log4j logging Understanding exceptions and thread dumps Troubleshooting errors that occur in Tomcat Troubleshooting errors generated by your deployed applications Troubleshooting strategies applicable to application servers other than tomcat Connecting databases with Tomcat applications Classic JDBC approach Better approach: JNDI resources Setting up and monitoring database connection pools Security File system security Java security manager Realms, authentication, and authorization SSL Java VM and Tomcat Performance tuning strategies Additional JVM tuning tips Enabling parallel garbage collection Building native connectors Disabling/removing unneeded applications Tuning incoming connections and database connection pools Turning off Jasper development mode Precompiling JSPs Preloading servlets Application-specific tuning suggestions Tuning levers available in other application servers The World Beyond Tomcat: Understanding Java EE Applications Explanation of the Java EE APIs not supported by Tomcat: EJB, JMS, and many others 3rd party application frameworks overview (what they are and what administrators should know): Spring, Struts 1/Struts 2, JSF (including a discussion of ICEfaces, RichFaces, etc.) Data tier frameworks and what administrators should know (Hibernate, JPA, etc.) Features offered by WebLogic, WebSphere, and JBoss that are not found in Tomcat Tomcat Other Features Memory leak prevention and detection Servlet 3.0, JSP 2.2, and EL 2.2 support (and the practical implications of this for Tomcat admins) Cross-site request forgery prevention (and how to configure) How Tomcat 7's new session management features prevent session fixation attacks Alias support (which allow static content to be stored outside the WAR file) Running Tomcat behind Apache httpd or IIS [this section would be taught using your web server and connector module of choice] Why run Tomcat behind Apache httpd or IIS? Installing mod_jk (Apache or Tomcat) or mod_proxy_ajp and mod_proxy_balancer (Apache 2.2 or later only) Proxying traffic to Tomcat via AJP Monitoring the status of your web server's connection to Tomcat Load balancing Tomcat via mod_jk or mod_proxy_balancer Tomcat Clustering Configuring mod_jk (in Apache or IIS) or mod_proxy_balancer (Apache 2.2 or later only) as a load balancer Hardware load balancing as an alternative to software load balancing Sticky sessions Configuring a shared session back-end FileStore/JDBCStore (older approach, generally not recommended) Using the <Cluster> tag Configuring the application to be distributable Setting up and testing failover |
| resin | Resin: Setting up a Java Application server for web applications spanning hundreds of servers | 14小时 | Resin is a fast and reliable open-source Java Application Server for web applications spanning hundreds of servers. Originating as a Servlet and JSP engine, Resin today supports Web Profile, CDI and EJB. Resin includes a high performance JTA transaction manager, a JMS provider, clustering, connection pooling, and a management console. Resin is used by companies such as CNET, Motorola and Salesforce.com. In this course, we cover the essentials of installing, configuring, securing, optimizing and managing a Resin application server. By the end of the course, participants will have a firm understanding of Resin's architecture, features and capabilities and will have will the practice needed to deploy and manage their own Resin application server. Audience System administrators Enterprise web application developers DevOps engineeers Format of the course Part lecture, part discussion, heavy hands-on practice Introduction Installation Overview of the Resin directory structure Starting the Resin server Configuring Resin Monitoring and administration Deploying local and distributed applications Connecting to multiple databases Using Resin's logging features Working with the Resin HTTP server Security: setting up authentication and authorization in Resin Developing applications with Resin Testing applications with Resin API for JUnit Deploying with Resin Clustering and load balancing your Resin server Performance tuning for Resin Closing remarks |
| wfsadm | WildFly Server Administration | 14小时 | This course is created for Administrators, Developers or anyone who is interested in managing WildFly Application Server (AKA JBoss Application Server). This course usually runs on the newest version of the Application Server, but it can be tailored (as a private course) to older versions starting from version 5.1. Module 1: Installing Core Components Installing the Java environment Installing JBoss AS Application server features Creating a custom server configuration Module 2: Customizing JBoss AS Services How to monitor JBoss AS services JBoss AS thread pool Configuring logging services Configuring the connection to the database Configuring the transaction service Module 3. Deploying EJB 3 Session Beans Developing Enterprise JavaBeans Configuring the EJB container Module 4: Deploying a Web Application Developing web layout Configuring JBoss Web Server Module 5: Deploying Applications with JBoss Messaging Service The new JBoss Messaging system Developing JMS applications Advanced JBoss Messaging Module 6: Managing JBoss AS Introducing Java Management Extension JBoss AS Administration Console Managing applications Administering resources |
| DEVOPSJEE | Fundamentals of Devops for Java Enterprise Edition Projects | 21小时 | This training course introduces the core DevOps concepts and principles as well as the ways to stand up the DevOps practice in your organization. It is specifically focused on projects on the Java Platform. Upon completion of this training course, students will have a fundamental understanding of DevOps’ value proposition; they will also gain practical experience working with select DevOps tools, including Puppet, Jenkins, Git and others. This training course is supplemented by hands-on labs that help attendees reinforce their theoretical knowledge of the learned material. Topics: DevOps practices and tools Puppet Technical introduction to cloud computing Jenkins 1. Introduction Establish Goals and Current State The Goal of DevOps 2. What Is DevOps? Background and History Symptoms and Problems in Today's Environment The IT Core Chronic Conflict DevOps Roles DevOps Defined Core Concepts 3. Ball Point Game 4. Why Do DevOps? Driving Factors Amazon's Process: A Case Study State of DevOps Report Manufacturing and DevOps 5. DevOps at Microsoft – a Case Study Dark Launches Feature Flags Agile to DevOps Branching Teams Live Site Culture 6. How Does DevOps Work Continuous Integration Continuous Deployment Continuous Delivery Continuous Testing Continuous Monitoring Automation Kanban End-to-End 7. Culture and DevOps People and Trust Resilience Engagement is Key Change the Metrics! Law of Motivation Keys to Successful DevOps Culture 9. Tool Time Build Automation Test Automation Deployment Automation Git Environment Provisioning Automated Feedback and Monitoring 10. DevOps Assessment 12. Summary and Next Steps In-Class Exercises: Individual and Team Goals – Identifying current issues and goals The Ball Point Game – Creative team game to learn about process optimization The Penny Game – see how Kanban and batch sizes affect delivery DISC Assessment – personality / culture exercise DevOps Assessment – Where Are We? |
| javafunmanven | Java fundamentals with Maven | 28小时 | The course covers the basics of Java development and introduces the Apache Maven software project management and comprehension tool. Getting Started The Java Technology Phenomenon How to write basic "hello world" application How to compile and execute Java code How to make the code a bit more complex Introducing Apache Maven Convention over Configuration Maven Plugins Conceptual Model of a Project Installing and Running Maven Downloading and Installing Maven Testing a Maven Installation Getting Help with Maven A Simple Maven Project Creating a Simple Project Building a Simple Project Simple Project Object Model Java Syntax Object-Oriented Programming Concepts Variables, arrays, data types, operators, and control flow What are reference variables Classes and objects What inheritance is and how it works What Interfaces are, why they are written and how How to use Java String and Number objects and how to format data for output What packages are for and why we must use import directive Java Objects Java classes overview Java class life cycle Class modifiers and inheritance Overloading" and overriding Class constructors Polymorphism Relationships: IS and HAS 'static' keyword When to use static members Using objects within an application deployed with Maven Customizing a Maven Project Customize Project Information Add New Dependencies Add Resources Building a Packaged Command-Line Application Optimizing and Refactoring Maven POMs POM Cleanup Optimizing Dependencies Optimizing Plugins Final POMs Java Collections Collection interface Lists, maps and sets Collections and arrays Concurrency Manage collections with an application deployed with Maven Java Memory Garbage collector Heap and stack Object life cycle 'finalize()' method Java Exceptions The general idea of Java Exceptions Runtime and 'real' exceptions Throwing an exception 'try...catch' statements 'throws' declaration Designing your own exceptions Test and manage exceptions with an application deployed with Maven A multimodule project with Maven Building the Multimodule project Running the Multimodule application Java Concurrency Threads and concurrency Threaded tasks Joining threads Class variables visibility Build and run a multithread application with Maven |
| springboot | Spring Boot: Rapidly build Spring-based web applications | 14小时 | Spring Boot is a Java-based web application development framework that favors convention over configuration. Spring Boot allows developers to create stand-alone, production-grade applications that "just run", typically on an embedded instance of Tomcat, Jetty, or Undertow. Spring Boot's "opinionated view" of the Spring platform and third-party libraries allows for minimum-fuss application development that requires very little configuration. These Spring Boot applications require no code generation or XML configuration. They feature integrated health monitoring, simplified Maven configuration, and a host of other features that make building, deploying, and running Spring applications relatively straightforward. In this training, participants learn the key features and architecture of Spring Boot, and its relationship to the underlying Spring framework. Ample opportunities for applying this knowledge and receiving feedback is provided by the instructor as participants step through live, hands-on exercises on defining, configuring and deploying Spring applications. By the end of the course participants will have the necessary knowledge and practice to rapidly deploy their own Spring application. Audience Java web application developers Format of the course Heavy emphasis on hands-on practice. Most of the concepts are learned through samples, exercises and hands-on development. Introduction Spring Framework: from 2002 to now Spring Boot: building on top of the Spring framework Spring Boot architecture and fundamentals Overview of MVC Initializing your project in Eclipse Using Groovy to script Spring Boot Using Spring Boot CLI Building and deploying an application Using templates to serve up dynamic HTML Running Spring Boot application starters Accessing data with Spring Data Configuring Spring Boot properties Spring Boot metrics and health checks Securing your application with Spring Security Authentication and authorization Interacting with a JMS broker Closing remarks |
近期课程
| 课程 | 日期 | 价格【远程 / 传统课堂】 |
|---|---|---|
| Java Persistence with Hibernate - 北京 - 创而新大厦 | 星期三, 2017-10-11 09:30 | ￥18200 / ￥22200 |
| Administering GlassFish Server with Java EE applications introduction - 钰海环球金融中心 | 星期三, 2017-10-11 09:30 | ￥26750 / ￥29150 |
| Quality Assurance and Continuous Integration - 深圳 - 新世界中心 | 星期四, 2017-10-12 09:30 | ￥17750 / ￥22930 |
| REST API - a pattern of exchange of information between sites - 上海 - 上海中区广场 | 星期一, 2017-10-16 09:30 | ￥17750 / ￥22930 |
| Struts 2 Framework - 上海 - 六八八广场 | 星期二, 2017-10-17 09:30 | ￥26810 / ￥29210 |
Java,培训,课程,培训课程, Java课程,Java周末培训,Java远程教育,Java教程,Java辅导班,Javas辅导,企业Java培训,Java训练,Java老师,Java培训师,Java私教,短期Java培训,学习Java ,Java晚上培训,学Java班,Java讲师,小组Java课程
