千锋2019JAVA学习路线图+学习资料+面试题

————————————————————————————————————————————————————

面试题

 

第一套
1.hadoop运行原理
包括HDFS和Mapreduce两部分。
1）HDFS自动保存多个副本，移动计算。缺点是小文件存取占用namenode内存，写入只支持追加，不能随机修改。
它存储的逻辑空间称为block，文件的权限类似linux。整体架构分三种节点，NN,SNN,DN
NN 负责读写操作保存metadata(Ownership Permission blockinfo)
SNN 负责辅助NN合并fsimage和edits，减少nn启动时间
DN 负责存数据，每个数据（文件）分割成若干block，每个block默认3个副本。启动后像NN发送心跳保持联系
NN保存的metadata在hdfs启动后加载到计算机内存，除block位置信息的metadata保存在OS文件系统中的fsimage文件中，对metadata的操作日志保存在OS文件系统中的edits文件中。block位置信息是hdfs启动后由DN上报NN再加载到内存的。
HDFS的安全模式：直到NN完全加载完metadata之前的这段时间。期间不能写入文件，DN检查各个block完整性，并修复。
2）MapReduce
离线计算框架，过程分为split map shuffle reduce四个过程
架构节点有：Jobtracker TaskTracker
Split将文件分割，传输到mapper，mapper接收KV形式的数据，经过处理，再传到shuffle过程。
Shuffle先进行HashPartition或者自定义的partition，会有数据倾斜和reduce的负载均衡问题；再进行排序，默认按字典排序；为减少mapper输出数据，再根据key进行合并，相同key的数据value会被合并；最后分组形成（key,value{}）形式的数据，输出到下一阶段
Reduce输入的数据就变成了，key+迭代器形式的数据，再进行处理
2.MapReduce原理
逻辑上：
1、split
2、map
3、shuffle
4、reduce
四个过程
物理上：
JobTracker节点：JobTracker创建每一个Task（即MapTask和ReduceTask）
并将它们分发到各个TaskTracker服务中去执行。负责调度Job的每一个子任务task运行于TaskTracker上。
TaskTracker节点：运行在多个节点上的slaver服务。TaskTracker主动与JobTracker通信，接收作业，并负责直接执行每一个任务。TaskTracker都需要运行在HDFS的DataNode上

3.hdfs存储机制
1） client端发送写文件请求，namenode检查文件是否存在，如果已存在，直接返回错误信息，否则，发送给client一些可用namenode节点
2） client将文件分块，并行存储到不同节点上datanode上，发送完成后，client同时发送信息给namenode和datanode
3） namenode收到的client信息后，发送确信信息给datanode
4） datanode同时收到namenode和datanode的确认信息后，提交写操作。
4.用MapReduce找出存在公共好友的两个人
数据样本:
A:B,C
B:A,E
C:A,D
D:C
E:B

import java.io.IOException;
import java.util.ArrayList;
//import java.util.Collection;
//import java.util.Map.Entry;
//import java.util.HashMap;
import java.lang.Iterable;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
//import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.util.ToolRunner;
import org.apache.hadoop.util.Tool;
import org.apache.commons.lang.StringUtils;

public class FindUsers extends Configured implements Tool  {
    
    static class Map extends Mapper {
        public void map(LongWritable key, Text val, Context context) throws IOException, InterruptedException {
        
            String line = val.toString();
            String user = line.split(":")[0];
            String[] friends = line.split(":")[1].split(",");
            String joined_friends = StringUtils.join(friends, ",");
            for(String friend : friends) {        
                int result = friend.compareTo(user);
                if(result > 0) {
                    context.write(new Text(user + "," + friend), new Text(joined_friends));
                } 
                else if(result < 0) {
                    context.write(new Text(friend + "," + user), new Text(joined_friends));
                }
            }
        }
    }
    
    static class Reduce extends Reducer {
        public void reduce(Text key, Iterable vals, Context context) throws IOException, InterruptedException {
            String string_key = key.toString();
            String[] users = string_key.split(",");
            ArrayList list = new ArrayList();
            
            int i = 0;
            
            String state = "Off";
            for(Text val : vals) {
                i++;
                String[] all_people = val.toString().split(",");
                ArrayList inner_list = new ArrayList();
                
                if(state.equals("Off")) {
                    for(String one_people: all_people) {
                        list.add(one_people);
                        state = "On";
                        continue;
                    }
                    
                }
                
                if( state.equals("On")) {
                    for(String one_people: all_people) {
                        inner_list.add(one_people);
                    }
                }

                list.retainAll(inner_list);
            }
            
            if( ! users[0].equals(users[1])) {
                for(String user : users) {
                    if(list.contains(user)) list.remove(user);
                }
                if(list.size() >= 1 && i >=2) {
                    context.write(new Text(StringUtils.join(users, ",")), new Text(StringUtils.join(list,",")));
                }
            }
        }
    }

    @Override
    public int run(String[] args) throws Exception {
            
        Job job = Job.getInstance(getConf());
        job.setJarByClass(getClass());
        
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        
        //job.setNumReduceTasks(0);
        job.setMapOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        return job.waitForCompletion(true) ? 0 : 1;
    }

    
    public static void main(String[] args) throws Exception {
        ToolRunner.run(new FindUsers(), args);
        
    }
}

5.用mr设计一个分组排重计数算法
输入文件格式:二级域名,一级频道,二级频道,访问ip地址,访问者id
需求:按照二级域名,一级频道,二级频道分组,计算pageview数,计算独立ip数和独立访问者id数

6.hadoop中combiner的作用
当map生成的数据过大时，带宽就成了瓶颈，怎样精简压缩传给Reduce的数据，有不影响最终的结果呢。有一种方法就是使用Combiner，Combiner号称本地的Reduce，Reduce最终的输入，是Combiner的输出
第二套
1.    单例
5种写法，1、懒汉2、恶汉3、静态内部类4、枚举5、双重校验锁
1、
class LazySingleton{
    private static LazySingleton singleton;
    private LazySingleton(){
    }
    public static LazySingleton getInstance(){
        if(singleton==null){
            singleton=new LazySingleton();
        }
        return singleton;
    }   
}

2、
class HungrySingleton{
    private static HungrySingleton singleton=new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
        return singleton;
    }
}

3、
class InternalSingleton{
    private static class SingletonHolder{
        private final static  InternalSingleton INSTANCE=new InternalSingleton();
    }   
    private InternalSingleton(){}
    public static InternalSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

4、
enum EnumSingleton{
    INSTANCE;
    public void doSomeThing(){
    }
}

5、
class LockSingleton{
    private volatile static LockSingleton singleton;
    private LockSingleton(){}
     
    //详见：http://www.ibm.com/developerworks/cn/java/j-dcl.html
    public static LockSingleton getInstance(){
        if(singleton==null){
            synchronized(LockSingleton.class){
                if(singleton==null){
                    singleton=new LockSingleton();
                }
            }
        }
        return singleton;
    }
     
}
2.    Linkedlist和ArrayList的区别
ArrayList是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

3.http安全问题
    1)重要信息:MD5,AES加密
    2)不太重要的数据:用签名
    3)登录态:
4.sparkStreaming和storm的区别

5.gc
自动监测对象是否超过作用域从而达到自动回收内存的机制，Java语言没有提供
释放已分配内存的显式操作方法。

第三套•乐视
1.design a singleton class in multi-threading environment.
2.How to find middle element of linkedlist in one pass.
3.Reverse singly linked list in java recursively.
4.Write a java program to implement Stack in java.
Public class MyStack{
    Private ArrayList data = new ArrayList();
    Public Boolean pop(){}
    Public Boolean push(){}
}
1.    scala 隐函数关键字
implicit
2.    val x=y=1结果
1)x、y都是var，x变为Unit
2)都是val，报错
3.java内存模型
堆内存、栈内存、方法区
栈内存：保存局部变量
堆内存：存储数组和对象
方法区：代码区、字符串常量池、静态区
3.    spark运行的job在哪里可以看到

4.    HADOOP的一个job提交到resourcemanager之后，会生成什么容器来放这个job

 

第四套•优酷
1.    java内存模型
2.gc
3.编译好的scala程序，运行时还需要scala环境吗
Scala的代码执行是用REPL过程，Read Execute Print Loop
4.object中有哪些方法
5.监测集群中的cpu，内存使用情况？
6、ArrayList中的Array长度超了是怎么增加的，一次增加多少？

第五套
linux的启动顺序
通电后读取ROM的BIOS程序进行硬件自检，自检成功后把计算机控制权交给BIOS中BOOTsequence中的下一个有效设备，读取该设备MBR找到操作系统，载入linux的bootloader，一般是grub。之后载入kernel，执行 /etc/rc.d/sysinit ，开启其他组件（/etc/modules.conf），执行运行级别，执行/etc/rc.d/rc.local ，执行/bin/login，最后shell启动。
使用过的开源框架介绍
Struts2 
Spring 
hibernate 
mybatis
hadoop
hive
hbase
flume
sqoop
Zookeeper
Mahout
Kafka
Storm
Spark
擅长哪种技术
Hadoop。介绍
HIVE的优化
底层是MapReduce，所以又可以说是MapReduce优化。
1.    小文件都合并成大文件
2.    Reducer数量在代码中介于节点数*reduceTask的最大数量的0.95倍到1.75倍
3.    写一个UDF函数，在建表的时候制定好分区
4.    配置文件中，打开在map端的合并
开发中遇到的问题
Hbase节点运行很慢，发现是Hfile过小，hbase频繁split。
修改了hfile大小。或者设置major compack设置为手动
Major compack设置为手动会出现什么问题
？
Zookeeper的二次开发

Flume 的实时和定时数据采集，项目和flume的解耦

Mogodb和hbase的区别
Mogodb是单机
Hbase是分布式？？
项目组多少人？人员分配？数据量？集群的配置？

第六套•优化相关
Hbase优化
1）    表设计
建表时就分区，rowkey设置定长（64字节），CF2到3个
Max Versio，Time to live，Compact&Split
2）    写表
多Htable并发写
Htable参数设置，手动flush，降低IO
WriteBuffer
批量写
多线程并发写
3）    读表
多Htable并发读
Htable参数设置
批量读
释放资源
缓存查询结果
MapReduce优化
  1.  任务调度 
    I/O 方面：Hadoop 会尽量将 Map 任务分配给 InputSplit 所在的机器，以减少网
络 I/O 的消耗。 
  2.数据预处理与 InputSplit 的大小 
    合理地设置 block块大小是很重要的调节方式。除此之外，也可以通过合理地
设置 Map 任务的数量来调节 Map 任务的数据输入。 
  3. Map 和 Reduce 任务的数量 
    当 Reduce 任务的数量是任务槽的 1.75 倍时，执行速度快的机器可以获得更多
的 Reduce 任务，因此可以使负载更加均衡，以提高任务的处理速度。 
  4. Combine 函数 
    MapReduce 框架运行用户写的 combine 函数用于本地合并，这会大大减少网
络 I/O 操作的消耗
Oracle优化
1、建立视图 
2、优化 sql 语句
3、分表、分库
4、存储过程
Spark优化
第七套•scala
scala 语言有什么特点，什么是函数式编程？有什么优点 

2.scala 伴生对象有什么作用 
3.scala 并发编程是怎么弄得，你对 actor 模型怎么理解有何优点 
4.scala case class  有什么重要 
5.scala akka 框架有没有接触过，有什么重要 
6.scala 为什么设计 var   和 val

第八套•spark
SDD,DAG,Stage怎么理解？
宽依赖 窄依赖怎么理解？
Stage是基于什么原理分割task的？
血统的概念
任务的概念
容错方法
粗粒度和细粒度
Spark优越性
Spark为什么快
Transformation和action是什么？区别？举几个常用方法
SDD怎么理解
spark 作业提交流程是怎么样的，client和 cluster 有什么区别，各有什么作用
spark on yarn  作业执行流程，yarn-client  和 yarn cluster 有什么区别
spark streamning 工作流程是怎么样的，和 storm 比有什么区别
spark sql  你使用过没有，在哪个项目里面使用的
spark  机器学习和 spark 图计算接触过没，，能举例说明你用它做过什么吗？
spark sdd 是怎么容错的，基本原理是什么？

第九套•java
1．关于 string 的选择题 
2．修饰符 
3．两个整数相除，保存到百分位 
4．写个封装，抽象，继承，多态的类集。 
5．jsp 的作用域的描述。
6．如何得到 jsp 的参数。
7．写几个 SQL 语句。

第十套•美团(3-7)
1.  说说 hbase 的 API 都有哪些 filter? 
2.  说说你用过的 storm? 
3.  自己熟悉大数据的部分说一下？
4. hadoop 与 storm、spark 的比较？
5.  对一个字符串进行全排列？
6. 事务都有哪些特点？
7. hadoop 集群中的某个 block 不能 copy 数据到其他节点，怎么办？如果并发量大
了， 有多个 block不能 copy 数据，怎么办？
8. flum 是如何导入数据到 kafka?具体
9. 请使用 awk, sed 命令对文本文件中第二列和第三列取出来(58同城)

 

 

其他整理
1、 用户文件 2 个属性 10 万行，课程文件 2 个属性 2 万行，日志文件 1 个属性很
大，这些属性可以任意的组合查询，每秒的请求数是 10000 个，请如何最快的方式查
询出数据？
2、给你 2 个字符串，字符串最后一个字符可以循环到最前面，只要一个字符串中每
一个字符在另一个字符串都有就是相等的，请用你的方法比较是否相等？
3、任意使用MR或者Storm或者hive根据日志表，求20150501当天每个用户访问页面次数的前10的页面，日志表如下：
Userid pageid viste date
Aa    222    20150501
Aa    333    20150501
Aa    222    20150501
Aa    222    20150502
Bb    333    20150501
Cc    333    20150502
4、Hbase的major compact和minor compact的区别
5、A表有三个字段，id,name,age，id为主键，去除该表中name重复的数据，用mysql语法实现（千万级别查询量、考虑Sql语法的复杂性）
6、算法：TB级别数据排序
    1）单机实现 2）分布式实现
7、static synchronized final volatile
8、concurrentHashMap的数据结构和应用场景
9、多线程的3种实现，说明他们的优缺点
10、JVM的内存模型，GC在何时何地，做了什么事情
11、用java实现LRU缓存
12、实现单例，要求：线程安全、锁的性能
13、目录拷贝功能：目录下上万文件需要拷贝备份，拷贝同时输出进度
14、jps命令作用
15、a和b两个文件各存放80亿URL，每个URL64字节，内存限制为4G，如何找出共同的URL
16、start-hbase.sh为起点hbase的启动流程
17、hbase的compact
--------------------- ——————————————————————————

JAVA视频教程汇总

2019Java视频教程：JavaEE初级

Java开发入门

本课程适合完全小白的你学习，内容从计算机基本概念，DOS命令开始，为你入门编程语言扫盲，什么是程序，如何配置JAVA开发环境，JAVA编程的过程是怎样的，JAVA有什么物特点，程序是如何运行的，这些你都可以在这里得到答案。

Java编程基础

本课程介绍JAVA编程的基础语法，共分为10个知识点，我们将学习变量，基本数据类型，进制，转义字符，运算符，分支语句和循环语句等，以达到训练基础语法和逻辑能力的目的，你知道如何不通过第三个变量来交换两个数吗？答案在这里。

方法与数组

本课程介绍方法（也可以称为函数）的使用，用方法来组织代码，最基本的好处就是达到代码复用的目的，不仅如此，方法更有不可告人的目的，接着介绍数组的用法和特点，结合常用的算法介绍，这个最基本的线性数据结构蕴含着无限的能量。

面向对象（上）

本课程介绍JAVA面向对象的基本概念，我们将从14个知识点来分别介绍类与对象，封装性，对象内存结构分析，static关键字，到第一个设计模式，对于没有接触过面向对象的你来说，你要准备好会晕车了，想要顺利到站，需要你坚持边学边练哦。

面向对象（下）

本课程继续面向对象，共有21个知识点，详细介绍了继承，多态，内部类，5个设计模式的应用，链表数据结构的纯手工代码实现，让你深入浅出，彻底揭开面向对象的神秘面纱，是修炼JAVA基本功的必备秘籍。

2019Java视频教程：JavaEE中级

Eclipse与异常处理

本课程内容介绍Eclipse集成开发环境的基本使用，掌握Eclipse在项目开发中使用率超过90%，是开发的必备利器；JAVA的异常处理无处不在，本章介绍异常处理的用法与异常发生的原理与处理过程，结合JDK1.7的新特性，让我们的异常处理代码更加优雅，最后介绍Eclipse的debug技术，为开发复杂应用调试做好充分准备。

常用类库

本课程内容介绍常用类库API的使用及原理分析，数据结构二叉树实现，JDK1.8 Lambda表达式的语法与应用，共15节视频，通过本章内容的学习，达到熟练使用这些 API，恭喜你，你已经步入 JAVA 核心技术的高级开发阶段了。

文件与IO

本课程内容介绍文件基本操作，IO流体系中的各种流的特点与用法，共分为25节详细介绍了普通流的应用与源码分析，NIO的原理与使用，结合装饰者设计模式的实现来更好的理解流的体系结构，本章节的涉及的类多，学习本章内容需要仔细总结各个流的特点与用法，结合API的查阅，多做练习，一进一出，你会懂的。

集合

本章课程内容讲解JAVA中的集合框架体系，包括Collection接口中的List接口和Set接口，Map接口的实现类使用及原理源码分析，深入浅出的讲解内部实现细节，让你知其然也知其所以然，本章内容还加入JDK1.8的新特性，比如Stream、四大函数式编程接口等，通过迭代器设计模式的介绍，来理解Iterator的实现模式，最后讲解项目开发中常用的第三方框架Guava的使用来提高项目开发中效率，集合的难点，在于掌握底层数据结构的原理，在这里，你都可以一一收获。

多线程与并发

本章课程内容我们开始引入 当今 JAVA 开发最好的IntellijIDEA开发环境，然后介绍进程与多线程的基本概念，线程的实现方式与特点深入理解，最后配合一个经典的生产者与消费者案例，来讲解多线程之间的任务协作，通过本章节内容的学习，你可以充分掌握多线程开发的核心思想，实话告诉你，到你研究 JavaEE框架源码的时候，它会派上用场。

网络编程

本章课程内容从介绍网络编程基本概念，TCP协议，UDP协议的区别，通过演示服务器与客户端之间的通信，到多客户端之间的通信来实现一个简易版的聊天程序，网络下载，最后介绍Apache开源项目网络通信框架MINA。掌握本章内容的目的是理解网络编程基础原理，为后续WEB开发中的网络操作提供底层知识支持。

反射与内省

本章课程内容从介绍反射的基本概念和API使用入手，结合动态代理模式介绍来使用反射，JavaBean的概念介绍与Apache开源工具BeanUtils的使用，Introspector相关API与案例演示，手把手教你实现一个简易版的AOP框架，为JAVAEE的后续课程打好充分的基础理论，最后，结合以上章节的知识，优化单例设计模式。

泛型

本章课程内容介绍泛型的使用，自定义泛型类、泛型接口和泛型方法，通配符的使用，以及通配符的上限下限，完成本章节的学习，可以掌握泛型在开发中的运用。

正则表达式

本章课程内容介绍正则表达式的语法与示例演示，了解正则表达式可以为后续WEB开发中使用JavaScript的正则提供帮助。

枚举

本章课程内容介绍枚举的使用，枚举是JDK1.5后新增的新特性，使用枚举可以为使用者提供固定的选择项，以避免调用者输入非法选项值，但使用枚举比使用普通常量会消耗更多的性能，在实际使用场景时需要考虑。

注解

本章课程内容介绍注解的使用，注解Annotation是JDK1.5后新增的新特性，注解在后续EE开发的框架或Android开发的组件中使用很多，比较常见的是spring2.5开始的基于注解配置通过注解，为我们在代码中添加信息提供了一种形式化的方法，学完本章内容让你对如何使用注解及定义注解有比较清晰的了解。

XML与JSON

本章课程内容介绍XML文件的作用及应用场景，介绍四种XML的解析方式：SAX/DOM/JDOM/DOM4J以及比较分析，第三方组件xStream的使用，JSON数据的解析与生成，GSON组件的使用等，通过本章节的学习，掌握网络数据传输的概念，在未来EE企业级开发中，XML与JSON的数据交换是非常常见的。

GUI事件处理

本章课程内容简单介绍了GUI编程，由于JAVA中的GUI几乎在企业级开发中无用武之地，所以不作为重点内容，本章的核心内容是介绍基于GUI编程中的事件处理机制，以及接口回调的概念，结合观察者设计模式的讲解，来掌握事件的概念及使用，该知识点在Android开发中使用甚广，在WEB开发中让我们更好的理解底层框架代码。

项目实战

通过本项目实战课程，把JAVA基本部分的内容融会贯通，体验项目开发的基本流程，谁说用基础写不了项目，主要看怎么写，跟谁写。

2019Java视频教程：JavaEE中高级

Mybatis框架实战教程

本门课程围绕MyBatis的基本使用、动态sql、高级查询等知识点讲解了如何使用MyBatis开发应用程序。同时也介绍了如何使用逆向工程创建MyBatis应用程序。通过入门程序的演示对MyBatis作了简要的介绍,深入学习MyBatis的参数传递、排序查询等功能,介绍了动态sql语句，完成复杂的sql查询；介绍了如何使用逆向工程提高开发效率；介绍了MyBatis的缓存机制；介绍了嵌套查询、嵌套结果以及扩展结果查询的方式；介绍了MyBatis中构造方法和鉴别器的使用以及如何在MyBatis中配置延迟加载。

Spring框架实战

这门课程主要讲Spring的核心概念和基本使用。涉及IoC、DI、AOP、JdbcTemplate和事务管理等核心概念。同时讲解了xml和注解两种方式使用Spring的示例。通过Spring的入门程序介绍了Spring的 IoC 和 DI 的概念，介绍了Spring的基本模块。

SpringMVC框架实战

这门课程主要介绍了目前最流行的一个MVC框架-SpringMVC。主要介绍了SpringMVC中注解的使用、数据的传输、类型转换、json处理、异常处理、拦截器和图片上传等功能。同时也介绍了如何在SpringMVC中处理json数据。最后通过一个项目介绍了如何将Spring、SpringMVC和MyBatis整合起来。

容灾项目实战

这个项目是一个框架阶段的总结项目。主要用到了Spring、SpringMVC、Hibernate三大框架搭建项目。同时使用了Shiro完成项目中的用户认证和用户权限处理。使用了quartz实现了定时任务。整合了druid的监控中心。使用aop开发了日志系统。前端框架使用vue实现。

2019Java视频教程：JavaEE高级

分布式基础知识点

本章主要讲解Linux常见命令，Jdktomcat配置，maven私服，阿里云配置redis和mysql等基础知识点。

互联网金融p2p

本章主要讲解p2p项目的搭建，从分布式环境搭建到项目整合，从solr搭建到移动端交互加密，进行了系统完整的介绍。完整的P2P项目体系,有相关的文档介绍，结合分布式体系进行讲解，对于并发时候的资金安全保障进行相关优化。

MySQL主从分离和优化

本套视频包括了分布式中各种环境如何搭建：Linux 系统CentOS7的安装、Redis单机版的安装等。

Spring Boot实战

本视频教程包括了SpringBoot的基本使用及SpringBoot如何和各项技术整合。微服务和Spring Cloud实战：本套课程涉及Eureka、Feign、Ribbon、Hystrix、Turbine、Zuul、Configserver等知识点。

Java编程工具

Eclipse：一个开放源代码的、基于Java的可扩展开发平台 。
NetBeans：开放源码的Java集成开发环境，适用于各种客户机和Web应用。
IntelliJ IDEA：在代码自动提示、代码分析等方面的具有很好的功能。
MyEclipse：由Genuitec公司开发的一款商业化软件，是应用比较广泛的Java应用程序集成开发环境 。
EditPlus：如果正确配置Java的编译器“Javac”以及解释器“Java”后，可直接使用EditPlus编译执行Java程序 。