面试问题

面试问题

zookeeper和eureak的区别

Consistency: 一致性，数据一致更新，所有的数据都是同步的

Availability:可用性，好的相应性能

Partition：可靠性

一个分布式系统不可能同时满足C（一致性）、A（可用性）和P（分区容错性）。由于分区容错性在分布式系统中是必须要保证的，因此我们只能在A和C之间权衡。故在此Zookeeper保证的是CP，而Eureka则保证的是AP。

工厂设计模式

package dome;

工厂设计模式
import oracle.jvm.hotspot.jfr.Producer;
// 工厂类
public class SimpleFactory {

    public static Proudct creatProducer(String type) {
        if (type.equals("A"))
            return new ProudctA();
        else
            return new ProudctB();
    }

    public static void main(String[] args) {
        Proudct proudct = SimpleFactory.creatProducer("B");
        proudct.print();
    }
}

// 抽象父类
abstract class Proudct {
    public abstract void print();
}

//子类继承
class ProudctA extends Proudct {
  //重写方法
    @Override
    public void print() {
        System.out.println("产品A");
    }
}
//子类继承
class ProudctB extends Proudct {
  //重写方法
    @Override
    public void print() {
        System.out.println("产品B");
    }
}

JDK动态代理设计模式

给某一个对象提供一个代理，并由代理对象控制原对象
  
  

package dome.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public interface Person {
    void eat();
}
class Bod implements Person{
    @Override
    public void eat() {
        System.out.println("Bod在吃饭");
    }
}
// JDK 动态代理类
class JDKPorxy implements InvocationHandler{
    //被代理的对象
    private Person person;

    //构造函数
    public JDKPorxy(Person person) {
        this.person = person;
    }
    //获取代理对象
    public Object getProxyClass(){
        /**
         * ClassLoader loader,  用哪个类加载器去加载代理对象
         * Class<?>[] interfaces, 动态代理类需要实现的接口
         * InvocationHandler h   动态代理方法在执行时，会调用h里面的invoke方法去执行
         */
        Object proxyInstance = Proxy.newProxyInstance(person.getClass().getClassLoader(), person.getClass().getInterfaces(), this);
        return proxyInstance;
     }

    /**
     * 代理原方法执行增强
     * @param proxy
     * @param method  执行原方法
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("增强");
        // 原方法执行
        Object invoke = method.invoke(person, args);
        System.out.println("增强");
        return null;
    }
}
class Test{
    public static void main(String[] args) {
        Person proxyClass = (Person) new JDKPorxy(new Bod()).getProxyClass();
        proxyClass.eat();
    }
}

集合

两大集合

• Collection

  • Set:无序,唯一
    • HashSet
      • 底层数据结构是哈希表。(无序,唯一)
      • 如何来保证元素唯一性?依赖两个方法：hashCode()和equals()
    • LinkedHashSet
      • 底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
        • FIFO 先进先出
      • 由链表保证元素有序
      • 由哈希表保证元素唯一
    • TreeSet
      • 底层数据结构是红黑树。(唯一，有序)
        • 如何保证元素排序的呢?
        • 自然排序
        • 比较器排序
        • 如何保证元素唯一性的呢?
        • 根据比较的返回值是否是0来决定
  • List:List 有序,可重复
    • LinkedList
      • 优点: 底层数据结构是链表，查询慢，增删快。
      • 缺点: 线程不安全，效率高
    • ArryList
      • 优点: 底层数据结构是数组，查询快，增删慢。
      • 缺点: 线程不安全，效率高
    • Vector
      • 优点: 底层数据结构是数组，查询快，增删慢。
      • 缺点: 线程安全，效率低

• MAP

  • TreeMap
    • 有序
  • Hashtable
    • 无序，线程安全，效率低，不能为null，方法是同步的
  • HashMap
    • 无序，效率高，不安全可以，为null，方法是不同步

  Hashtable的父类是Dictionary，HashMap的父类是AbstractMap

IOC控制反转

将你设计好的对象交给容器控制，这样的过程是控制反转

以前我们在A类中 通过自身new一个B类，现在我们把newB类的事情交给spring来做，在我们调用的时候会容器会给为我们实例化

IOC 容器的初始化过程

• Resource资源定位，既定义bean的xml的载入

• 将Resource定位好的资源载入BeanDefinition

• 将BeanDefinition注册到容器中

• ioc的初始化过程中，一般不包含依赖注入的实现，springioc中注册和依赖注入是两个过程，依赖注入是一般发生在第一次索取bean的时候，但是也可以在xml中，在容器初始化的时候，这个bean就完成了初始化

  • 三种注入方式

    • 构造方法注入
    • set注入
    • 基于注解的注入
    • bean的创建 工厂模式
    • 数据的注入 反射

  ioc 是spring两大核心之一，spring为我们提供了一个ioc的bean容器，这个容器会帮助我们自动创建对象，还有一个就是di依赖注入我们可以写java代码或者xml配置的方式把我们想要注入对象所依赖的其他的bean自动的注入进去通过type或者类型的方式帮我们自动注入正是有这个依赖注入使我们ioc有非常强大的东西就是解耦

AOP

核心:代理 ，JDK动态代理必须实现接口，而spring底层用的是cgib动态代理

SpringMVC

MVC设计模式

首先了解一下MVC，MVC设计模式

用户发起一个请求Controller控制器交给模型层处理 M-Model 模型完成业务逻辑：有javaBean构成service+dao+entity然后返回一个处理结果给控制器，调用V-View 视图（做界面的展示 jsp，html……）

然后派发给用户

SpringMVC执行流程

• 用户发出url请求到前端控制器
• 前端控制器收到请求到处理器映射器
• 处理器映射根据用户请求找到具体的处理器，生成处理器执行链一并返回给控制器
• 控制器根据处理器获取处理适配器执行一些系列操作，参数封装，数据格式转换，数据验证等操作
• 执行处理器
• 返回ModelAndView
• 处理器适配器将处理器执行的ModelAndView返回给前端控制器
• 前端控制器将返回的传给视图解析器
• 视图解析器解析后返回给具体的view
• 前端控制器对view 进行渲染 然后响应给用户

事物

递归

es