【JAVA】- 知识点小结

时间 2019-11-08

标签 JAVA 知识小结栏目 Java 繁體版

原文原文链接

java面向对象编程

面向对象(概念)：前端

面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，
扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工
智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到必定阶段后的产物。
复制代码

三大特性：
- 封装：java
  
  封装，就是把客观事物封装成抽象的类，而且类能够把本身的数据和方法只让可信的类或者对象操做，对不可信的进行信息隐藏。一个类就是一个封装类了数据以及操做这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据能够是私有的，不能被外界访问。经过这种方式，对象对内部数据提供了不一样级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。mysql
- 继承：web
  
  继承，指可让某个类型的对象得到另外一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可使用现有类的全部功能，并在无需从新编写原来的类的状况下对这些功能进行扩展。经过继承建立的新类称为“子类”或“派生类”，被继承的类称为“基类”，“父类”或“超类”。继承的过程，就是从通常到特殊的过程。要实现继承，能够经过“继承”和“组合”来实现。继承概念的实现方式有两类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称，可是子类必须提供实现的能力。redis
- 多态：算法
  
  多态，是指一个类实例的相同方法在不一样情形有不一样表现形式。多态机制使具备不一样结构内部的对象能够共享相同的外部接口。这意味着，虽然针对不一样对象的具体操做不一样，但经过一个公共的类，它们（那些操做）能够经过相同的方式予以调用。spring
五大原则
- 单一职责原则（SRP）sql
  
  是指一个类的功能要单一，不能一应俱全。如同一我的同样，分配的工做不能太多，不然一天到晚虽然忙忙碌碌的，但效率却高不起来。mongodb
- 开放封闭原则（OCP）数据库
  
  一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。
- 里氏替换原则（LSP）
  
  子类应当能够替换父类并出如今父类可以出现的任何地方。
- 依赖倒置原则（DIP）
  
  高层模块不该该依赖低层模块，两者都应该依赖其抽象；抽象不该该依赖细节，细节应该依赖抽象。
  依赖倒置的核心思想是面向接口编程。依赖倒置的一个核心原则就是下降耦合性
- 接口分离原则（ISP）
  
  模块间要经过抽象接口隔离开，而不是经过具体的类强耦合起来。
高内聚，低耦合
- 高内聚
  
  高内聚是针对类内部的方法而言，把程序的功能尽可能分散，别在一个类里只写一个方法，这样会给调试等带来不少麻烦。
  
  所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一原则。
- 低耦合
  
  低耦合是针对类与类之间的关系而定，意思是类之间的关系要简单，不要有很强的依赖关系，否则，运行起来就会出问题，使一个类的运行影响到其余的类。

经常使用的设计模式

blog.csdn.net/qq_33326449…

单例模式

一个类在java虚拟机中只有一个对象，并提供一个全局访问点

解决问题：对象的惟一性，性能浪费太多。
应用场景：数据库链接对象，属性配置文件的读取对象。
模式结构：饿汉式和懒汉式（若是考虑性能的话，就用懒汉式，由于懒汉式是在方法里面进行初始化的），构造器私有化，对外提供方法加同步关键字。

饿汉式：
public class HurgrySingleton {  
    private static HurgrySingleton hurgry=new HurgrySingleton();  
    private HurgrySingleton(){};  
    public static HurgrySingleton getSinletonHurgry(){  
        return hurgry;  
    }  
}    
复制代码

懒汉式：
public class LarzySingleton {  
   private static LarzySingleton larzy=null;  
   private LarzySingleton(){};  
   public static synchronized Larzy getSinletonLarzy(){  
        if(larzy==null){  
              larzy=new LarzySingleton();  
        }  
        return larzy;  
    }  
}  
复制代码

简单工厂

用一个方法来代替new关键字

Spring的核心就是工厂模式。

解决问题：对象产生过多，或者常常有子类替换生成。
应用场景：对于常常生成的对象，或者父子类替换生成。
模式结构：写一个对外声明的方法，方法里面使用new关键字代替。

public class UserFactory {  
     public static User createUser(int i){  
    //若是输入的是1，就建立它的子类，不然就建立父类  
         if(i==1){  
             return new Alices();  
          }  
         return new User();  
     }  
}  
复制代码

代理模式（Proxy）

为其余对象提供一个代理，以控制对当前对象的访问

Spring里面的AOP实现。

解决问题：不能直接访问该对象，或者太大的资源耗费多。
应用场景：权限，或者大对象的访问权限。
模式结构：代理类和被代理类实现同一个接口，用户访问的时候先访问代理对象，而后让代理对象去访问被代理对象。

建立一个接口：
public interface SellHouse {  
    void sell(double money);  
}  

建立一个被代理类：
public class Hoster implements SellHouse {  
    @Override  
    public void sell(double money) {  
        System.out.println("祝你居住愉快");  
    }  
}  

建立一个代理类：
public class Medium implements SellHouse {  
    SellHouse hoster=new Hoster();  
    @Override  
    public void sell(double money) {  
        if(money>=1000){  
            hoster.sell(money);  
        }else{  
            System.out.println("你的价格过低了");  
        }  
    }  
}  

测试类：
public class Renter {  
    public static void main(String[] args) {  
        SellHouse renter=new Medium();  
        renter.sell(500);  
    }  
}  
复制代码

适配器模式

将两个原来不兼容的类兼容起来一块儿工做

类适配器和对象适配器的区别：类适配器经过继承来完成适配，对象适配器则是经过关联（组合）来完成。

解决问题：以及存在的相同功能的代码，可是接口不兼容，不能直接调用。
应用场景：在使用旧的API的时候，没有源码，和新的不能兼容。
模式结构：分为类适配器和对象适配，通常经常使用的就是对象适配器，由于组合优于继承。
类适配器：

在目标接口中的 request() 调用 Adaptee 的 adapteeRequest() 方法呢？

已存在的将被适配的类：
public class Adaptee {
    public void adapteeRequest() {
        System.out.println("被适配者的方法");
    }
}

定义一个目标接口：
public interface Target {
    void request();
}

适配器类：
public class Adapter extends Adaptee implements Target{
    @Override
    public void request() {
        //...一些操做...
        super.adapteeRequest();
        //...一些操做...
    }
}
复制代码

对象适配器：

public class Adapter implements Target{
    // 适配者是对象适配器的一个属性
    private Adaptee adaptee = new Adaptee();

    @Override
    public void request() {
        //...
        adaptee.adapteeRequest();
        //...
    }
}
复制代码

策略模式

定义一系列算法并能够互相替换

解决问题：作一件事情有不少种方法。
应用场景：购物车里面的付款方式。
模式结构：声明一个顶级接口，定义一个策略方法，具体的实例都要实现这个接口。

定义一个顶级接口：
public interface Person {  
    void repast();  
}  

具体的实例类1:
public class African implements Person {  
    @Override  
    public void repast() {  
        System.out.println("非洲人用手吃饭");  
    }  
}  

具体的实例类2:
public class America implements Person {  
    @Override  
    public void repast() {  
        System.out.println("美国人用刀叉吃饭");  
    }  
}  

具体的实例类3：
public class Chinese implements Person {  
    @Override  
    public void repast() {  
        System.out.println("中国人用筷子吃饭");  
    }  
} 

测试类：
public class Test {  
    public static void main(String[] args) {  
        Person chinese=new Chinese();  
        Person america=new America();  
        Person african=new African();  
        chinese.repast();  
        america.repast();  
        african.repast();  
    }  
}  
复制代码

模版模式

父类定义流程，子类实现流程

解决问题：业务有多种，但都有规定的流程。
应用场景：通常基类的实现都是模版模式，BaseDAO，bBaseService
模式结构：定义一个抽象父类定义流程，或者经常使用方法和常量，子类继承父类，实现具体的细节方法。

定义父类，定义流程：
public abstract class IPhoneTemplate {  
    public void createIPhone(){  
        setupCpu();  
        setupAll();  
        check();  
        box();  
    }  
    protected abstract void box();  
    protected abstract boolean check();   
    protected abstract void setupAll();  
    protected abstract void setupCpu();   
} 

子类实现父类的细节方法1:
public class ChinaIPhone extends IPhoneTemplate {  
    @Override  
    protected void box() {  
        System.out.println("box()");  
    }  
    @Override  
    protected boolean check() {  
        System.out.println("check()");  
        return true;  
    }  
    @Override  
    protected void setupAll() {  
        System.out.println("setupAll()");  
    }  
    @Override  
    protected void setupCpu() {  
        System.out.println("setupCpu()");  
    }  
} 

子类实现父类的细节方法2：
public class AfricanIPhone extends IPhoneTemplate {  
    @Override  
    protected void box() {  
        System.out.println("box()");  
    }  
    @Override  
    protected boolean check() {  
        System.out.println("check()");  
        return true;  
    }  
    @Override  
    protected void setupAll() {  
        System.out.println("setupAll()");  
    }  
    @Override  
    protected void setupCpu() {  
        System.out.println("setupCpu()");  
    }  
} 
复制代码

项目管理工具
- Maven
  - 优势:
  1. Maven是一个项目管理和综合工具。Maven提供了开发人员构建一个完整的生命周期框架。
  2. 在多个开发团队环境时，Maven能够设置按标准在很是短的时间里完成配置工做，使开发人员的工做更加轻松。
  3. Maven增长可重用性并负责创建相关的任务。
  - 缺点:
  1. maven是一个庞大的构建系统，学习难度大
  2. maven采用约定优于配置的策略（convention overconfiguration），虽然上手容易，可是一旦出了问题，难于调试。
  3. 当依赖不少时，m2eclipse 总是搞得Eclipse很卡。
  4. 中国的网络环境差，不少repository没法访问，好比google code， jboss 仓库没法访问等。
- SVN
  - 优势：
  1. 管理方便，逻辑明确，符合通常人思惟习惯。
  2. 易于管理，集中式服务器更能保证安全性。
  3. 代码一致性很是高。
  4. 适合开发人数很少的项目开发。
  - 缺点：
  1. 服务器压力太大，数据库容量暴增。
  2. 若是不能链接到服务器上，基本上不能够工做，看上面第二步，若是服务器不能链接上，就不能提交，还原，对比等等。
  3. 不适合开源开发（开发人数很是很是多，可是Google app engine就是用svn的）。可是通常集中式管理的有很是明确的权限管理机制（例如分支访问限制），能够实现分层管理，从而很好的解决开发人数众多的问题。
- Git
  - 优势:
  1. 适合分布式开发，强调个体。
  2. 公共服务器压力和数据量都不会太大。
  3. 速度快、灵活。
  4. 任意两个开发者之间能够很容易的解决冲突。
  5. 离线工做。
  - 缺点：
  1. 学习周期相对而言比较长。
  2. 不符合常规思惟。
  3. 代码保密性差，一旦开发者把整个库克隆下来就能够彻底公开全部代码和版本信息。
经常使用的一些开源框架
- SpringBoot
  - 什么是springboot？
    
    用来简化spring应用的初始搭建以及开发过程使用特定的方式来进行配置（propertites或yml文件）
    
    建立独立的spring引用程序main方法运行
    
    嵌入的tomcat无需部署war文件
    
    简化maven配置
    
    自动配置spring 添加对应功能starter自动化配置
  - springboot经常使用的starter有哪些？
    
    spring-boot-starter-web嵌入tomcat和webkaifa须要servlet与jsp支持
    
    spring-boot-starter-data-jpa数据库支持
    
    spring-boot-starter-data-redis数据库支持
    
    spring-boot-starter-data-solr solr支持
    
    mybatis-spring-boot-starter第三方的mybatis集成starter
  - springboot自动配置的原理
    
    在spring程序main方法中添加@SpringBootApplication或者@EnableAutoConfiguration会自动去mavenzhong读取每一个starter中的spring.factories文件，该文件配置了全部须要被建立spring容器中的bean
  - springboot读取配置文件的方式
    
    springboot默认读取配置文件为application.properties或者application.yml
- SpringCloud
  - 什么是微服务？
    
    之前的模式是全部的代码在同一个工程中部署在同一个服务器中同一个项目的不一样模块不一样功能互相抢占资源
    
    微服务将工程根据不一样的业务规则拆分红微服务微服务部署在不一样的机器上服务之间进行相互调用
    
    java微服务的框架有dubbo（只能用来作微服务），springCloud（提供了服务的发现，断路器等）
  - 什么是spring cloud？
    
    SpringCloud为开发人员提供了快速构建分布式系统的一些通用模式（例如配置管理，服务发现，断路器，智能路由，微代理，控制总线，一次性令牌，全局锁，领导选举，分布式会话，群集状态）。分布式系统的协调致使了锅炉板模式，而且使用Spring Cloud开发人员能够快速地站起来来实现这些模式的服务和应用程序。它们能够在任何分布式环境中正常工做，包括开发人员本身的笔记本电脑，裸机数据中心和受管平台，Cloud Foundry。
  - springcloud如何实现服务的注册和发现
    
    服务在发布时指定对应的服务名（服务名包括了IP地址和端口）将服务注册到注册中心（eureka或者zookeeper）
    
    这一过程时springcloud自动实现，只须要在main方法添加@EnableDisscoveryClient 同一个服务修改端口就能够启动多个实例
    
    调用方法：传递服务名称经过注册中心获取全部的可用实例，经过负载均衡策略调用（ribbon和feign）对应的服务
  - SpringCloud断路器的做用
    
    当一个服务调用另外一个服务因为网络缘由或者自身缘由出现问题时，调用者就会等待被调者的响应，
    
    当更多的服务请求到这些资源时，致使更多的请求等待，这样就会发生连锁效应，断路器就是解决这一问题的。
```
断路器有彻底打开状态：
必定时间内，达到必定的次数没法调用，而且屡次检测没有恢复的迹象，断路器彻底打开，那么下次的请求不会请求到该服务。

半开：
短期内有回复迹象，断路器会将部分请求发送给服务，当能正常调用时，断路器关闭。

关闭：
当服务一直处于正常状态，能正常调用，断路器关闭。
复制代码
```
- SpringMVC
  - 对SpringMVC框架的理解：
    
    mvc指的是Model（业务模型），View（视图），Controller（控制器）
    
    SpringMVC就是Spring框架的一个模块，因此它能够和spring框架进行无缝结合，它是一个基于mvc设计思想的前端web层框架，主要做用就是对前端请求进行处理。它的前端控制器是一个servlet，它的请求拦截是基于方法级别的。
  - 执行流程：
    
    SpringMVC框架主要由DispatcherServlet，处理器映射，处理器（控制器），视图解析器，视图组成。
```
1. 客户端请求提交到DispatcherServlet
2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找处处理请求的Controller
3. DispatcherServlet将请求提交到Controller
4. Controller调用业务逻辑处理后，返回ModelAndView
5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
6. 视图负责将结果展现到客户端
复制代码
```
- Spring
  
  Spring通常是做为容器管理其余框架
  - AOP：面向切面编程
    
    AOP：面向切面编程，将跟业务逻辑没有关系的代码提取出来，在调用目标方法以前或者以后执行。经常使用的场景，事务，日志，权限控制，异常处理等方面。
  - IOC：控制反转
    
    IOC：建立对象的权利，交给spring容器建立。
  - DI：依赖注入
    
    DI：若是一个对象A须要使用另外一个对象B才能实现某个功能，这时就能够说A对象依赖于B对象，而spring容器在建立A对象时，会自动将A对象须要的B注入到A对象中，此过程就是依赖注入。
  - 核心容器
    
    核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
  - Spring上下文
    
    Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
  - Spring AOP：
    
    经过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。因此，能够很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。经过使用 Spring AOP，不用依赖 EJB 组件，就能够将声明性事务管理集成到应用程序中。
  - Spring DAO：
    
    JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不一样数据库供应商抛出的错误消息。异常层次结构简化了错误处理，而且极大地下降了须要编写的异常代码数量（例如打开和关闭链接）。Spring DAO 的面向 JDBC 的异常听从通用的 DAO 异常层次结构。
  - Spring ORM：
    
    Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、 Hibernate 和 iBatis SQL Map。全部这些都听从 Spring 的通用事务和 DAO 异常层次结构。
  - Spring Web 模块
    
    Web 上下文模块创建在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。因此， Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工做。
- MyBatis
  - 对Mybatis的理解
    
    Mybatis是一个优秀的ORM框架，应用在持久层，它对jdbc的操做数据库过程进行封装，使开发者只关注SQL自己，而不须要花费精力去处理例如注册驱动，建立connection，等jdbc繁杂的过程代码，通常用mapper代理的方式开发，直接在xml里面写sql。
  - Mybatis的工做流程
```
1. mybatis配置
SqlMapConfig.xml，此文件做为mybatis的全局配置文件，配置类mybatis的运行环境等信息。
2. 经过mybatis环境等配置信息构造SqlSessionFactory即会话工厂。
3. 由会话工厂建立sqlSession即会话，操做数据库须要经过SqlSession（DefaultSqlSession）进行。
4. mybatis底层自定义类Executor（BaseExecutor）执行器接口操做数据库，Executor接口有
两个实现，一个是基本执行器、一个是缓存执行器。
5. Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。
mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id便是Mapped statement的id。

6. Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor经过
Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对
preparedStatement设置参数。

7. Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor
经过 Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程至关于jdbc
编程中对结果的解析处理过程。
复制代码
```
- Hibernate
  - 对hibernate的理解
    
    Hibernate是轻量级的持久层解决方案，是一个关系数据库ORM框架, 对JDBC访问数据库的代码作了封装.咱们能够很容易的对数据库进行增删改查操做.
  - hibernate的查询方式
    
    （1）导航对象图检索方式。根据已经加载的对象，导航到其余对象。
    
    （2）OID检索方式。使用get或者load加载对应的对象
    
    （3）HQL检索方式。
    
    （4）QBC检索方式。
    
    （5）SQL检索方式。
  - sql与hsql的区别
    
    （1）sql是直接操做数据库的
    
    （2）hql是经过操做对象操做数据库，对大小写敏感。
  - 一级缓存和二级缓存的区别
    
    一级缓存是session级别的缓存，二级缓存是sessionFactory级别的缓存。
  - hibernate中get和load的区别？
    
    get和load都是根据id获取数据。
    
    （1）get先查询session中对应id是否有数据，若是有则直接返回，有查询数据库，如数据库中没有则返回为null；
    
    （2）load方式查询session中对应id是否有数据，若是没有生成代理对象，查询数据库。如没有对应的id则抛出异常
    - hibernate和mybatis对比？
    1. 在移植性方面hibernate配置一下方言便可.而通常状况下mybatis则须要修改sql语句
    2. hibernate是一个彻底的ORM框架.彻底的面向对象.更符合咱们开发者的思惟模式.mybatis须要咱们手动写sql语句
    3. hibernate的优化成本比较高.由于hibernate的sql语句是自动生成的,因此在优化方面通常的新手无从下手.而mybatis只要修改sql就能够了.更加容易上手
- Spring Data JPA
  
  JPA意即Java持久化API，是在JDK5.0后提出的持久化规划，JPA的出现主要是为了简化持久层开发以及整合ORM技术。
  - ORM映射元数据：支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系。
  - API：操做实体对象来执行CRUD操做
  - 查询语言：经过面向对象而非面向数据库的查询语言（JPQL）查询数据，避免程序的SQL语句紧密耦合。
  使用SpringData建立查询
```
1. 声明一个接口继承自Repository或Repository的一个子接口，对于Spring Data JPA一般是JpaRepository
  2. 在接口中声明查询方法，如findOneByCustomerId（）
  3. 在application.properties或在application.yml文件中配置几个属性便可。
  4. 在须要的接口中注入Reposotiry便可。
复制代码
```
- Spring Data Mongodb
  
  hibernate是传统数据库的ORM框架(Object Relational Mapping对象关系映射，简称，ORM)
  
  mongoDB是nosql的非关系型数据库
  
  mongoDB的ORM框架,有mongoDB官方提供Morphia框架或者spring-data-mongoDB框架
- Shiro
  - Shiro的优势
```
简单的身份认证, 支持多种数据源
对角色的简单的受权, 支持细粒度的受权(方法级)
支持一级缓存，以提高应用程序的性能；
内置的基于 POJO 企业会话管理, 适用于 Web 以及非 Web 的环境
很是简单的加密 API
不跟任何的框架或者容器捆绑, 能够独立运行
复制代码
```
  - Shiro架构的核心组件
```
Authenticator:管理登录登出
Autorizer:受权器赋予主体有那些权限
session Manager：shiro本身实现session管理器
session DAO：提供了session的增删改插
Cache Manager：缓冲管理器
Raelms：和数据库交互的桥梁
复制代码
```
  - Shiro认证过程
    
    建立SecurityManager -> 主体提交认证 -> SecurityManager认证 -> Authenticator认证 -> Realm验证
  - Shiro受权过程
    
    建立SecurityManager ->主体受权 -> securityManager受权 -> Authorizer受权 ->Realm获取权限数据
经常使用的数据库
- mysql
- mongodb
- oracle
- redis
memcached缓存框架

Memcached是一款开源的、高性能的纯内存缓存服务软件。Mem是内存的意思，cache是缓存的意思，d是daemon的意思。 memcache 是项目名称，也是一款软件，其架构是C/S架构。

缓存： 将数据存储到内存中，只有当磁盘胜任不了的时候，才会启用缓存

缺点：断电数据丢失(双电)，用缓存存储数据的目的只是为了应付大并发的业务。

数据库： mysql(关系型数据库，可以保证数据一致性，保证数据不丢失，当由于功能太多，致使性能不高) ===数据参考

缓存数据库： memcache redis(非关系型数据库，性能极高，但不保证数据完整性) === 业务的数据提供者
- memcachedb 会将内存的数据写入到磁盘中
- redis 主要工做场所是内存中，可是按期备分内存数据到硬盘
memcache优势：
```
①  对于用户来说，用户访问网站更快了，体验更好了。

  ②  对网站来讲，数据库压力下降了。只有当内存没有数据时才会去请求数据库。第一次写入的数据也会请求数据库。通常公司没有预热，只有当用户读取过数据库才会放到Memcached中。

  ③ 提高了网站的并发访问，减小服务器数量。
复制代码
```

Activiti工做流
- 什么是工做流，工做流的核心对象是什么，activiti共操做数据库多少张表
  - 工做流就是多个参与者，按照某种预约义的规则，传递业务信息，进行审核的功能一个框架（Activiti）
  - processEngine，调用Service，从而操做数据库的表
  - 23表
- 工做流中的接口
  - RepositoryService:流程定义和部署对象
  - RuntimeService：执行管理，包括流程实例和执行对象（正在执行）
  - TaskService：执行任务相关的（正在执行）
  - HistoryService：历史管理
  - IdentityService：Activiti表的用户角色组
消息中间件
- ActiveMQ
  
  ActiveMQ/ApolloMQ
  
  优势：老牌的消息队列，使用Java语言编写。对JMS支持最好，采用多线程并发，资源消耗比较大。若是你的主语言是Java，能够重点考虑。
  
  缺点：因为历史悠久，历史包袱较多，版本更新很缓慢。集群模式须要依赖Zookeeper实现。最新架构的产品被命名为Apollo，号称下一代ActiveMQ，目前案例较少。
- RabbitMQ
  
  优势：生态丰富，使用者众，有不少人在前面踩坑。AMQP协议的领导实现，支持多种场景。淘宝的MySQL集群内部有使用它进行通信，OpenStack开源云平台的通讯组件，最早在金融行业获得运用。
  
  缺点：Erlang代码你Hold得住不? 虽然Erlang是自然集群化的，但RabbitMQ在高可用方面作起来还不是特别驾轻就熟，别相信广告。
使用Dubbo分布式服务治理框架及Zookeeper分布式服务协调框架的运行原理及开发
- Dubbo
  - 什么是分布式？什么是集群？主要区别
    
    分布式是将一个服务分个部分，而后经过远程调用方式进行。远程调用框架RPC框架，spring cloud,dubbo。集群是将同一个服务的多个副本部署在不一样的集群上，经过负载均衡的方式提供复试。场景：厨师。
  - 服务治理包括哪些内容？
    
    服务治理须要服务治理框架，dubbo。即对服务进行管理，例如服务的接口名称，权重等信息。
  - 注册中心的做用？你怎么理解注册中心的？
    
    若是没有注册中心，须要在本地维护一个provider的地址列表。注册中心角色，它是集中式数据管理，消费者经过注册中心来访问数据。经过注册中心，使得provider和consumer之间是透明。
  - 什么是RPC？
    
    远程调用框架。
  - dubbo中负载均衡的策略有哪些？
    
    Provider: 集群，集群只须要重启几个实例便可。
    
    Zookeeper：集群
    
    Consumer：集群
    
    负载：Loadbalence轮询，随机

推荐使用zookeeper注册中心，还有redis等不推荐。
    核心配置有 dubbo:service/ dubbo:reference/ dubbo:protocol/ dubbo:registry/ dubbo:application/ dubbo:provider/ dubbo:consumer/ dubbo:method/
    dubbox是当当网基于dubbo上作了一些扩展，如加了服务可restful调用，更新了开源组件等。
复制代码

Zookeeper

ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，它是集群的管理者，监视着集群中各个节点的状态根据节点提交的反馈进行下一步合理操做。最终，将简单易用的接口和性能高效、功能稳定的系统提供给用户。

zookeeper是一个开源的分布式协调服务框架。
    应用场景：分布式通知/协调、负载均衡、配置中心、分布式锁、分布式队列等。
    Paxos算法。
    选举算法及流程。
    节点类型：持久节点、持久顺序节点、临时节点、临时顺序节点。
    部署模式：单机模式、伪集群模式、集群模式。
    集群须要一半以上的机器可用，因此，3台挂掉1台还能工做，2台不能。
复制代码

Tomcat服务器，Nginx+Tomcat负载均衡
Linux基本操做，基于CentOs的服务环境搭建以及项目部署
OAuth2协议的认证机制和运行原理
JWT Token认证安全管理
Hadoop生态系统，MapReduce计算模型，HDFS分布式文件系统的运行原理，搭建环境和API。
区块链技术，以太坊，智能合约，Solidity合约编码，Web3j编码，与智能合约集成开发以及私有链的部署。

【JAVA】- 知识点小结

java面向对象编程

三大特性：

五大原则

高内聚，低耦合

经常使用的设计模式

单例模式

简单工厂

代理模式（Proxy）

适配器模式

策略模式

模版模式

项目管理工具

Maven

SVN

Git

经常使用的一些开源框架

SpringBoot

SpringCloud

SpringMVC

Spring

MyBatis

Hibernate

Spring Data JPA

Spring Data Mongodb

Shiro

经常使用的数据库

mysql

mongodb

oracle

redis

memcached缓存框架

Activiti工做流

什么是工做流，工做流的核心对象是什么，activiti共操做数据库多少张表

工做流中的接口

消息中间件

ActiveMQ

RabbitMQ

使用Dubbo分布式服务治理框架及Zookeeper分布式服务协调框架的运行原理及开发

Dubbo

Zookeeper

Tomcat服务器，Nginx+Tomcat负载均衡

Linux基本操做，基于CentOs的服务环境搭建以及项目部署

OAuth2协议的认证机制和运行原理

JWT Token认证安全管理

Hadoop生态系统，MapReduce计算模型，HDFS分布式文件系统的运行原理，搭建环境和API。

区块链技术，以太坊，智能合约，Solidity合约编码，Web3j编码，与智能合约集成开发以及私有链的部署。