技术

Get Started. It's Free
or sign up with your email address
Rocket clouds
技术 by Mind Map: 技术

1. 接口

1.1. webservice

1.2. ecm中的与客户端连接方式

1.3. sokect

1.4. ecm接口的调用过程

1.5. 接口的安全考虑

1.6. restful风格的写法

1.7. 一些名词

1.7.1. wsdl(Web Services Description Language)

2. 测试

2.1. junit单元测试

2.1.1. 注解意思

2.1.2. junit的简单原理

2.1.3. junit与spring相结合

2.1.4. 测试覆盖率

2.1.4.1. 行覆盖率(一般也只能做到这一层了)

2.1.4.2. 逻辑覆盖率

2.1.5. spock

2.2. 集成测试

3. 数据库

3.1. nosql

3.1.1. moogdb

3.1.2. redis(很多人认为它是nosql,勉强算是吧内存数据库)

3.2. 图(低结构,多关系)

3.2.1. neo4j

3.3. 关系型

3.3.1. 一些常用的查询

3.3.1.1. insert

3.3.1.2. update

3.3.1.3. select

3.3.1.4. delete

3.3.1.5. with

3.3.2. 脚本,视图,自定义函数,存储过程

3.3.3. 执行计划及语句优化

3.3.4. 索引

3.3.5. 数据库的结构图

3.3.5.1. 物理结构

3.3.5.2. 逻辑结构

3.3.5.3. 数据库实例与数据库的概念区别

3.3.5.4. 一次完整的查询 逻辑是什么

3.3.6. 一些常用的函数及分析函数

3.3.6.1. over

3.3.6.2. rank() over

3.3.6.3. row_number()

3.3.6.4. rownum 原理。为什么row >1查不出数据

3.3.6.5. rownum与rowid概念及区别

3.3.6.6. 常用的函数

3.3.6.6.1. substr,trunc,to_date,

3.3.7. 数据库的隔离级别

3.3.7.1. mysql

3.3.7.1.1. read uncommit

3.3.7.1.2. read commit

3.3.7.1.3. repeatable read 默认

3.3.7.1.4. serializable

3.3.7.2. oracle

3.3.7.2.1. read only

3.3.7.2.2. read commit 默认

3.3.7.2.3. serializable

4. 前端

4.1.  js框架

4.1.1. jquery mobile

4.1.2. easyUI

4.1.3. ligerUI

4.1.4. jquery

4.1.4.1. jquery与dom对象的转换

4.1.5. 编写jquery 插件

4.2. css

4.3. html

4.4. bootstrp

4.5. 前端ui

4.5.1. amazue ui

5. linux

5.1. apache

5.1.1. apache内虚拟目录alias

5.1.2. 虚拟主机vhost

5.1.3. 目录,目录的权限规则

5.1.4. 代理 proxy给tomcate

5.1.5. 代理 做均衡配置 给tomcate做集群

5.2. netty

5.3. ngnix

5.4. ftp

5.5. mysql

5.6. svn

5.7. tomcat

5.8. 一些常用命令

5.8.1. rpm,yum等

5.8.2. top

5.8.3. 编写脚本。计划运行

5.8.4. ps -Ao comm,pmem,pcpu --sort -rss | uniq -c | head -15

5.9. 安全常识。比如帐户等

6. 安卓开发

6.1. 项目包结构及各目录的作用

6.2. 硬件天梯的结构与制做实例

7. java开发

7.1. 基础

7.1.1. hash的应用

7.1.2. map,set,list优缺点

7.1.2.1. Collection接口 提供iterator方法

7.1.2.1.1. list接口 提供listIterator方法,可以做更多的操作 与Set区别是,可以有多个重复element

7.1.2.1.2. set接口,类似于map接口,只不过set是对对象的集合。map是key-value的集合。

7.1.2.2. map接口 提供k-value的合集

7.1.2.2.1. hashTable类(同步)

7.1.2.2.2. hashMap类(不同步,线程不安全)

7.1.2.2.3. treeMap类(实现自NavigableMap接口,NavigableMap继承自sortMap接口)

7.1.2.2.4. WeakHashMap类

7.1.2.3. sortedSet接口 提供排序的方法

7.1.2.4. sortedMap接口 提供排序的方法

7.1.3. 重写equals方法

7.1.3.1. 为什么要重写

7.1.3.1.1. 业务需要 逻辑相等。 比如坐标对象.a(1,2,3) ,b(1,2,3) 从业务上来讲,他们就是相同的同东西。但是如果不重写equals的话,jvm就认为他是2个不同的东西。

7.1.3.2. 怎么重写

7.1.3.2.1. 任何对象都是继承自Object 的,Object有equals方法 与 hashCode方法。覆写的时候,写这2个方法就行了。

7.1.3.2.2. 一般重写equals方法需要遵从4个特性。

7.1.4. String a = new String("aa");创建了几个对象

7.1.4.1. 首先要搞清楚什么是对象,什么是引用,什么是new

7.1.4.1.1. 对象:一个类的具体实例化;

7.1.4.1.2. 引用:对象的别名,使用该别名可以存放该对象,编译器不会为引用分配空间,新对象与源对象共用一个存储地址空间; 引用的生命周期是它所引用的对象的生命周期!

7.1.4.1.3. new:在堆中开辟空间,创建一个对象的实例,并返回这个对象的引用(就是这个实例的地址)

7.1.4.2. 执行过程

7.1.4.2.1. 首先执行new String("aa") 。会首先看"aa"这个字符串在字串符常量池中有没有,没有的话,就会首先去创建一个,然后存在字串符常量池中。并返回地址。接着运行new String(),把字串符中的对象copy一份到堆空间,并返回地址给引用a. 这个时候可以看一下a == "aa",其实是返回false的。说明a的引用的对象的地址 是不等于"aa"的。

7.1.4.3. String a = new String("aa"); String ab = new String("aa"); 创建了几个对象

7.1.4.3.1. 这个时候就是创建了3个了

7.1.4.4. String.intern()

7.1.4.4.1. 对字串符进行初始化,看是否在字串符中存在,如果存在的话,就返回地址,如果不存在,先在池中创建1个,并返回地址

7.1.5. 关于java中是值传递,还是指针的传递

7.1.6. 浅拷贝,深拷贝

7.1.6.1. 浅拷贝(copy的是引用,引用改变的东西。他也会改变)

7.1.6.1.1. arrayList.clone()

7.1.6.1.2. addAll()

7.1.6.1.3. add()

7.1.6.2. 深拷贝

7.1.6.2.1. 序列化拷贝(将对象序列化之后,再反序列化)。实体需要继承Serializable.效率较低

7.1.6.2.2. 自己遍历集合.将每个有引用的都再clone一下.实体需要继承Cloneable

7.1.7. 反射。反射方法。反射属性。反射生成实例。

7.1.7.1. java.lang.reflect包

7.1.7.2. 常用方法

7.1.7.2.1. getDeclaredMethod

7.1.7.2.2. getDeclaredField

7.1.7.2.3. getField

7.1.7.2.4. getMethod

7.1.7.2.5. method.invoke()

7.1.7.2.6. setAccessible(true);

7.1.7.3. 注意事项

7.1.7.3.1. Declared方法不能获取继承的方法或者属性。注意!

7.1.7.3.2. setAccessible(true);在使用或者获取私有方法属性前要加这个来配置访问

7.1.8. jdk,jre这些名词的解释

7.1.9. java中的io库

7.1.9.1. 输入流 下边2个是平级的

7.1.9.1.1. inputstring 8位的byte

7.1.9.1.2. reader 16位的char

7.1.9.2. 输出流 同上

7.1.9.2.1. outputstring 8位的byte

7.1.9.2.2. writer 16位的char

7.1.10. 各种经典排序手写一下

7.1.10.1. 1.冒泡

7.1.10.1.1. 两两在位置上进行对比互换。

7.1.10.2. 2.比较排序

7.1.10.2.1. 第一遍,第1个与余下对比互换 第二遍,第2个与余下对比互换 。。。。

7.1.10.3. 快排

7.1.10.3.1. 运用递归

7.1.11. 各种关键词

7.1.11.1. native

7.1.11.1.1. 调用本地方法。跟操作系统有关的

7.1.11.2. try catch   finnaly .finnaly与return 的执行顺序

7.1.11.3. static

7.1.11.3.1. 声明一段内存空间,从对象被实例化之后一直存在。直到程序退出才会释放。 好处就是可以不用实例化而直接使用这段内存里的值。但是也有风险,因为所有程序是共享这段内存的。所以一般用来放置不变的量

7.1.11.4. public private protected

7.1.11.5. new

7.1.11.6. transient

7.1.11.6.1. 用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候,transient型变量的值不包括在串行化的表示中,然而非transient型的变量是被包括进去的

7.1.11.7. gwt

7.1.11.7.1. Google Web Toolkit的缩写,有了 GWT可以使用 Java 编程语言编写 AJAX 前端,然后 GWT 会交叉编译到优化的JavaScript 中,而 JavaScript 可以自动在所有主要浏览器上运行. 优点:类似于swing,awt编程。如果很擅长写这种的人,用起来很好。因为编译时进行了优化,所以编写出来的性能好,开发期间可调试。 缺点:稍微懂点儿html,js的人就不会去用它了。因为awt太麻烦。

7.1.11.8. final

7.2. 高级

7.2.1. 多线程

7.2.1.1. 线程安全

7.2.1.1.1. synchronized 同步

7.2.1.1.2. volatile 同步属性

7.2.1.1.3. lock 锁。1.6新增的

7.2.1.1.4. 各种线程安全的对象

7.2.1.2. 实现

7.2.1.2.1. 实现runable

7.2.1.2.2. 继承thread

7.2.1.2.3. 2者的区别

7.2.1.3. concurrent包

7.2.1.3.1. 线程池

7.2.1.3.2. 锁(lock)

7.2.1.3.3. future

7.2.1.3.4. 原子操作atomic

7.2.1.3.5. Semaphore(信号量)

7.2.1.3.6. Semaphore

7.2.2. jvm的结构

7.2.2.1. 计数器

7.2.2.1.1. 每个线程都有一个计时器,主要是记录当前 处理器 处理的位置,好去执行下一次的 处理器 处理。

7.2.2.2. 栈 vm stack

7.2.2.2.1. 指的是java方法执行的内存模式,每个方法被执行的时候就会创建一个栈帧用于存储局部变量表 操作栈,动态链接,方法出口等。每一个方法的生命周期 就相当于栈帧在虚拟机栈中从入到出的过程 。

7.2.2.3. 本地方法 native vm stack

7.2.2.3.1. 类似于vm stack ,不过里边是用于调用本地方法的

7.2.2.4. 堆 heap

7.2.2.4.1. 是被所有线程共用的区域,用来存放对象实例。是cg的主要回收者

7.2.2.5. 方法区 Method area(包括常量池)

7.2.2.5.1. 也是被所有线程共用。用来存放已被虚拟机加载的类信息,常量,静态亦是,即时编译器编译后的代码等。 就是class。每个class有自己的常量池,在vm里边还有一个常量池,维护所有的。

7.2.3. jvm什么时候进行gc,gc的方法.老年代,新生代,持久代

7.2.3.1. 引用的划分

7.2.3.1.1. 强引用:直接引用的。由虚拟机产生的。比如 Object object = new Object(); 这种引用,cg是不会收集他们的。

7.2.3.1.2. 软引用:引用关系还存在,但是不是必须的。 这个时候cg会根据剩余的内存去决定是否进行回收。 如果空间足够就不回收,会把它列入回收范围。等到空间不足的时候,才会进行回收,如果回收之后空间还是不足。就会报outOfMemory。

7.2.3.1.3. 弱引用:类似于软引用。不过它第一次就会被cg给回收掉。

7.2.3.1.4. 虚引用:比弱引用更弱的,给一个对象设置虚引用,基本目的就是为了对象被cg回收时 时得到一个系统通知。

7.2.3.2. 内存类型的划分

7.2.3.2.1. 新生代

7.2.3.2.2. 老年代

7.2.3.2.3. 持久代

7.2.3.3. gc算法

7.2.3.3.1. 标记-清除算法

7.2.3.3.2. 复制算法

7.2.3.3.3. 标记-整理算法

7.2.3.3.4. 分代清理

7.2.3.4. 垃圾收集器

7.2.3.4.1. 1.serial 收集器.特点:最早的收集器,需要停止 其他所有java线程来gc。单线程。。也是defNew

7.2.3.4.2. 2.parnew 收集器。 serial的多线程版

7.2.3.4.3. 3.serial old, 收集器 。 单线程 。

7.2.3.4.4. 4.parnew old 收集器。 多线程

7.2.3.4.5. 5.cms 标记-清理 以最短等待时间 为目标。费cpu

7.2.3.4.6. 6.g1 收集器 标记-整理 。短等时间 短

7.2.4. jdk参数设置

7.2.4.1. 堆大小

7.2.4.1.1. Xmx 最大可用内存 3550m

7.2.4.1.2. Xms 最小可用内存 3550m 一般与最大相同。减少cg后重新分配内存

7.2.4.1.3. Xmn 年轻代大小 2g 一般为整个jvm内存的3/8

7.2.4.1.4. Xss 栈大小 128K-1m 大小于jdk版本有关。 设置的越小,可生成的线程就越多。但是不是无限制的。需要根据配置慢慢调

7.2.4.1.5. XX:NewRatio 年轻代与老年代的比值(不算持久代)

7.2.4.1.6. XX:SurvivorRatio 年轻代中Eden与Survivor区的大小比值

7.2.4.1.7. XX:MaxPermSize 持久代大小。看大概你有多少个class等来计算。

7.2.4.1.8. XX:MaxTenuringThreshold =0 设置垃圾的最大年龄。设置为0则不经过Survivor区,直接进老年区。

7.2.4.2. 回收器

7.2.5. spring动态代理的2种模式

7.2.5.1. 自带的动态代理(java.lang.reflect),针对接口。静态代理

7.2.5.2. 第三方库cglib,没有限制。既可以接口实现,也可以生成类的子类并对方法进行覆盖来实现。 动态代码,在运行期间生成class。类似的还有什么ASM。。。

7.2.6. classload的双亲委派机制

7.2.7. java中的进程,线程

7.2.7.1. java中创建进程,是直接调用的系统进程。执行命令等也依赖于不同系统,不同版本的限制.Process p = new ProcessBuilder("")...

7.2.7.2. 线程。是实现了runable,继承thread。最后执行thrade.start()的方法来实现。其实质是,new thread来创建一个线程,然后线程调用run 方法

7.2.8. java中的进程 守护线程 用户线程

7.2.8.1. 守护线程与 用户线程基本差不多。只不过守护线程只能在jvm退出的时候进行退出。

7.2.9. stack 与 heap的区别

7.3. 框架

7.3.1. spring

7.3.1.1. spring解决了什么问题。比如ioc,解决什么。aop解决什么

7.3.1.1.1. ioc(Inversion of Control)控制反转

7.3.1.1.2. aop(Aspect Oriented Programming)面向切面编程

7.3.1.2. 事务管理机制

7.3.1.2.1. 如何配置

7.3.1.2.2. 概念

7.3.1.2.3. 实现原理

7.3.1.3. spring都用到了哪些设计模式

7.3.1.3.1. 简单工厂(静态工厂)

7.3.1.3.2. 工厂模式

7.3.1.3.3. 模板模式

7.3.1.3.4. 适配模式

7.3.1.3.5. 包装模式

7.3.1.3.6. 代理模式

7.3.1.3.7. 观察者模式

7.3.2. hibernate

7.3.2.1. 级联问题

7.3.2.2. 缓存机制

7.3.2.3. 怎么配置

7.3.2.3.1. 配置hibernate.xml

7.3.2.3.2. 配置实体bean

7.3.2.3.3. 配置实体bean的.xml配置文件

7.3.2.3.4. 继承hibernateDao写对应的dao层

7.3.3. mybatis

7.3.3.1. 原理是什么。画一个框架图

7.3.3.2. 怎么配置

7.3.3.3. 怎么方便配置。利用包扫描。自动加载mapper

7.3.3.4. 与spring如何结合

7.3.3.5. 怎么实现动态加载mapper而不用重启生效

7.3.4. struts

7.3.4.1. struts是做什么的

7.3.4.2. 怎么配置

7.3.4.3. 与spring如何结合

7.3.5. springMVC

7.3.5.1. springMVC是做什么的

7.3.5.2. springMvc的结构

7.3.5.3. 它的单例与struts2的多例比较

7.3.5.4. springMVC的声明式配置有什么优点缺点

7.3.5.5. springmvc的运行流程

7.3.6. 日志系统

7.3.6.1. slf4j

7.3.6.1.1. 最少包括slf4j api,以及最终使用的日志系统。

7.3.6.2. log4j

7.3.6.3. log4j2

7.3.7. 一些连接池

7.3.7.1. c3p0

7.3.7.2. gruid

7.3.8. jfinal

7.3.9. Grails

7.4. 常见的开源软件

7.4.1. 操作excel的包POI,jExcelAPI

7.4.2. 一些图表软件jfreeChart,hightChart

7.4.3. 一些报表软件  帆软

7.4.4. xml类的

7.4.5. json类

7.4.5.1. alibaba json

7.4.5.2. google json(gson)

7.4.5.3. jackjson

7.4.6. google的Guavaa工具类,针对java工具类的扩展

7.4.7. atomic 工具包 java.util.concurrent.atomic 对各种数字类型的对象提供原子操作

8. tomcat源码解析

8.1. 结构

8.1.1. server

8.1.1.1. service

8.1.1.1.1. connector

8.1.1.1.2. connector

8.1.1.1.3. engine

8.1.1.2. loggerListener

8.1.1.3. aprlifecycleListener

8.1.1.4. memoryListener

8.2. Digester

9. 监控

9.1. cat(大价点评的)

9.2. elk(Elasticsearch、Logstash、Kibana )

10. 设计模式

10.1. 一些思想

10.1.1. 开闭原则,即对扩展开放,对修改关闭

10.1.2. OOP 面向对象编程

10.2. 创建型模式

10.2.1. 简单工厂模式, 工厂方法模式(Factory Method)

10.2.1.1. 创建一个接口,或者抽象类。只暴露出1个创建方法,通过传入参数来获取实例。 用于高内聚,尽量少的暴露出内部方法

10.2.2. 抽象工厂模式

10.2.2.1. 工厂模式的升级版,因为需要多个工厂模式,所以把多个工厂模式进一步抽象,就成了抽象工厂模式。 可以简单的认为,简单工厂模式就是一层结构,抽象工厂模式就是多层结构了。

10.2.3. 单例模式

10.2.3.1. 全局调用

10.2.4. 创建者模式(Builder)

10.2.5. 原型模式(Prototype)

10.3. 结构型模式

10.3.1. 外观,门脸模式(face)

10.3.1.1. 把一大堆东西内聚成一个接口暴露出来,至于里边调用关系逻辑啥的,外部不用管。。 类似于接口。获取订单呀什么的,也是需要回馈信息的。 其他实现的话,看JS中JQUERY的api,SOCKS里的API反正是各种API基本就是这样的。

10.3.2. 代理模式(proxy)

10.3.2.1. 这个没啥好说的。用的太多了。现在的aop就是用它去实现的。 好处就是实现类是真正干活的,只要做好他的东西就行了,代理类是对它的进行包装,进行一其他其他额外操作,比如事务。

10.3.3. 适配器模式(Adapter)

10.3.3.1. 将一个接口改成可以使用的接口。 也许你会说,为什么不直接在“源”中直接添加方法, 我的理解是,适配是为了实现某种目的而为一个源类暂时性的加上某种方法, 所以不能破坏原类的结构。同时不这么做也符合Java的高内聚,低耦合的原理。 更多的其实是增加兼容性。比如一个JAR包,提供了某些功能。当时是1.0版本, 别人都用了。但这个时候你发布了2.0,别人如果想用的话,就得改功能。你为了不让他们改代码,就用这个。

10.3.3.2. 面向类适配

10.3.3.2.1. 类的适配模式用于单一源的适配,由于它的源的单一话,代码实现不用写选择逻辑,很清晰;

10.3.3.3. 面向对象适配

10.3.3.3.1. 而对象的适配模式则可用于多源的适配,弥补了类适配模式的不足,使得原本用类适配模式需要写很多适配器的情况不复存在, 弱点是,由于源的数目可以较多,所以具体的实现条件选择分支比较多,不太清晰。

10.3.3.4. 默认适配器模式。写了个接口,但是不想实现所有方法

10.3.4. 装饰,包装模式(Decorator)

10.3.4.1. 利用类的继承,添加改变类的属性或者功能。与适配器的不同,个人感觉在于,适配改变接口实现。。包装是增加职责,类似于嵌套。 典型应用。outputStream,inputStream

10.3.5. 桥模式(Bridge)

10.3.6. 组合模式(Composite)

10.3.7. 享元模式(Flyweight)

10.3.7.1. 类似于线程池的概念,最大的作用是复用,提升系统性能,节约内存空间。 不过享元模式下的对象不可替换,因为不同的实例服务的对象不一样。而线程池则是若干个相同的对象,可以互换的

10.4. 行为型模式

10.4.1. 观察者模式(Observer)

10.4.1.1. 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 类似于新闻消息推送。比如,有新新闻了,需要通知所有关心这个新闻的人。 jdk中有实现此机制的,在java.util.Observable中

10.4.2. 模板方法模式(Template Method)

10.4.3. 状态模式(State)

10.4.4. 策略模式(Strategy)

10.4.5. 职责链模式(Chain of Responsibility)

10.4.6. 命令模式(Command)

10.4.7. 访问者模式(Visitor)

10.4.8. 调停者模式(Mediator)

10.4.9. 备忘录模式(Memento

10.4.10. 迭代器模式(Iterator)

10.4.11. 解释器模式(Interpreter)

11. 常见的一些框架组合模式

11.1. 网仓一号所用到的一些整合

11.1.1. spring

11.1.2. mybatis

11.1.3. fr帆软

11.1.4. quartz

11.1.5. kettle

11.1.5.1. 大致原理

11.1.5.2. 与任务的结合

11.2. 小二快跑所用到的一些整合

11.2.1. spring

11.2.2. mybatis

11.2.3. springmvc

11.3. 本地通所用到的一些整合

11.3.1. spring

11.3.2. hibernate

11.3.3. struts

11.4. 微信公众平台

11.4.1. spring

11.4.2. hibernate

11.4.3. springmvc

11.4.4. jqueryui

11.5. reniling

11.5.1. spring

11.5.2. springmvc

11.5.3. mybatis

11.5.4. bootstrap

11.5.4.1. datatable

11.5.4.2. menutree

11.5.4.3. jquery

11.6. SSO通用权限验证,用于不同系统中,只登陆一次,来验证所有的

11.7. rsa加密。前端jsencript,后端java。

11.7.1. private key

11.7.2. public key

11.7.3. size

12. 通讯协议

12.1. get与post的区别,HTTP的6种动作

12.2. tcp与udp的区别。

12.3. http协议。1.0与1.1的区别

13. 正则表达

14. 版本,构建管理

14.1. SVN

14.2. GITHUB/git

14.3. maven

14.3.1. maven的几个生命周期

14.3.2. maven私服,远程库,本地库的一些区别及原理

14.4. maven的几个构建插件

14.4.1. jetty

14.4.2. tomcat

14.5. gradle

15. jms/消息机制

15.1. jmsAPI

15.1.1. ConectionFactory

15.1.1.1. QueueConectionFactory

15.1.1.2. TopicConnectionFactory

15.1.2. Destination

15.1.2.1. Queue

15.1.2.2. Topic

15.1.3. QueueBrowser

15.1.4. QueueRequest /TopicRequestor

15.1.5. TemporaryQueue/ TemporaryTopic

15.1.6. Connection

15.1.6.1. QueueConection

15.1.6.2. TopicConnection

15.1.7. Session

15.1.7.1. QueueSession

15.1.7.2. TopicConnection

15.1.8. Message

15.1.8.1. 公有的

15.1.8.2. TextMessage

15.1.8.3. ObjectMessage

15.1.8.3.1. 可序列化的对象

15.1.8.4. ByteMessage

15.1.8.5. StreamMessage

15.1.8.5.1. 相比与byteMessage,StreamMessage算是比较严格的按照类型定义的。 传的时候传long,收的时候必须按long来收,否则会报错。而byteMessage则不会按错。

15.1.8.6. MapMessage

15.1.9. MessageProducer

15.1.9.1. QueueSender

15.1.9.2. TopicPublisher

15.1.10. MessageConsumer

15.1.10.1. QueueReciver

15.1.10.2. TopicSubstriber

15.2. 消息模式

15.2.1. AUTO_ACKNOWLEDGE

15.2.1.1. 保证只传一次

15.2.2. DUPS_OK_ACKNOWLEDGE

15.2.2.1. 对上边只传

15.2.3. CLIENT_ACKNOWLEDGE

15.3. activeMq

15.3.1. 老牌的mq,实现jms接口,很众

15.4. rocketMq

15.4.1. 阿里实现的。不符合jms协议。

15.5. kafka

15.5.1. apache下的。以速度见涨。

15.6. RabbitMQ

16. 架构

16.1. activemq master/salve 主从配置。持久化到数据库

16.1.1. 持久化到数据库。添加数据源,变更存储方式为数据库

16.1.2. 相同的配置复制1份,放在另一台电脑(同一台电脑的话,改配置里的参数)。主要是起2个实例。

16.1.3. client端,用failer模式加载2个实例。2个broker实例会去查看数据库锁,如果一个broke挂掉。 另一个broken就会变成master。client端检测到不可用,就会去连另一个broken。这样来实现主从。

16.2. activeMQ + zookeeper 实现负载均衡

16.3. zookeeper

16.4. memcache服务端单例+客户端实例

16.5. 利用mycat中间层进行分表分库

16.6. springmvc+jackjson进行restfull接口提供

16.7. 国际化的几种实现场景

16.8. 长连接

16.8.1. websocket

16.8.2. 底层socket,自己实现

16.8.3. netty

16.8.4. mqtt协议

16.8.5. netty

16.9. 搜索框架

16.9.1. SOLR

16.9.2. Elasticsearch

16.9.3. 好多框架的背后的逻辑。lucence

16.10. 分布式文件系统

16.10.1. ceph

16.10.2. swfit

17. scala

18. dubbo

18.1. 参数序列化

18.2. 提供者

19. docker

19.1. dcoker原理

19.1.1. image

19.1.2. container

19.1.3. 网络

19.1.4. build

19.2. 各种命令

19.3. 加速

19.4. 私服

19.5. 运维化

20. 工具使用

20.1. idea

20.1.1. jrebel

20.1.2. lomboc

21. 事务