【总结】姿势点总结，做些微小的贡献

一 java

 

非阻塞io（nio）

传统io只对流操作，read、write等方法会使线程等待读写完成。非阻塞io为程序-缓冲buffer-通道channel-文件/网络的结构，将通道注册到多路复用器selector后使用，线程在读写时不会阻塞，提高运行效率。

二 数据库

1 sql优化，索引：主键索引、关联字段索引、常用字段索引，Btree；

2 mybatis

1.   一级缓存为会话级缓存，每个请求中执行的同一sql内容只查询一次，但期间有ddl操作时清空缓存；
2.   二级缓存为应用级缓存，需手动开启，多个请求中同一sql的结果在超时前只查询一次。
3.   使用xml映射sql与pojo对象，需手动编写sql。dao层可使用@Mapping注解的接口映射xml中配置的sql。方法不能重载，依靠方法名确定映射的sql。通过动态代理拦截方法调用，实际执行mybatis根据配置生成的相应sql的预处理对象MapperStatement。
4.   在sql中#{}为预编译，可防止注入，自动识别参数类型用占位符生成sql；${}为字符串替换。
5.   返回结果使用resultMap自定义映射，或指定pojo类名接受。
6.   批量sql，拼接insertall语句实现。
7.   增删改返回值为修改行数，设置usegeneratedkeys=”true” keyproperty=”id”后执行sql后id便赋予了对象的id字段。
8.   接口方法使用@Param注解参数，直接在sql中#{}注入参数。
9.   动态sql标签，根据参数值自动拼接sql条件。trim where if foreach bind set choose when otherwise

3 hibernate

1.   原理：启动时根据xml配置生成sessionFactory，业务逻辑中调用sql会话的方法以进行操作，由框架管理操作过程。
2.    get一次查完，load懒加载；都根据主键查询；无内容时get返回空，load抛异常。
3.    三种状态：new对象为临时态，查询结果为持久状态，临时态save成持久状态，持久状态、游离态delete成临时态，持久状态关闭为游离态，游离态save、update为持久态，游离态、临时态可被回收。
4.   一级缓存为会话缓存，会话内有效；二级缓存需第三方支持，时效内不更新，在cud操作少的场景使用。
5.    getCurrentSession由框架管理，openSession开启新会话，需要手动关闭。

4延迟加载：一对多对象的get发生调用时被拦截，若值为空则进行查询并set结果。

5锁：

1. 乐观锁，cud操作时累加版本字段值，在提交时检查是否过期，若过期则说明已有其它事务提交，回滚。效率高并发高不安全。Spring提供@Index注解标注版本字段。
2. 悲观锁，每次操作给数据加锁，效率低不能并发安全。

三 事务

 1 事务的四个特性：

1.   原子性：事务内容一并成功或失败；
2.   一致性：数据状态一致为事务提交前状态或提交后状态；
3.   隔离性：事务之间互相隔离互不影响；
4.   持久性：事务提交应持久化。

 2 事务并发问题：

1.   脏读：读取到未提交的数据，回滚后此数据不存在；
2.   不可重复读：读取数据后，此数据被修改（对应修改）；
3.   幻读：读取数据后，新增了符合条件的数据（对应插入）。

 3 事务四个隔离等级：（Spring还有个默认等级，依照数据库的等级，一般为读提交）

1.   读未提交：可读取事务cud但未提交的数据，可能脏读幻读不可重复读，不常用；
2.   读提交：事务提交后的数据才会被读取，避免脏读，常用，oracle默认等级；
3.   读锁/重复读：读数据时加锁，避免不可重复读，mysql默认等级；
4.   序列化：事务逐个进行，避免所有误读，效率低。

 4 事务七个传播等级：（Spring注解）

1.   新建子事务：PROPAGATION_REQURES_NEW，上下事务独立执行；
2.   嵌套子事务：PROPAGATION_NESTED，子事务回滚不影响上级事务，上级事务回滚子事务一并回滚；
3.   跟随：PROPAGATION_REQURED，子事务与上级事务为同一事务，默认等级；
4.   非事务/不支持：PROPAGATION_NOT_SUPPORTED，注解方法不参与事务；
5.   支持/有则加入：PROPAGATION_SUPPORTS，上级有事务则加入，无则非事务执行；
6.   必须有事务：PROPAGATION_MANDATORY，上级有事务则加入，无则异常；
7.   必须非事务：PROPAGATION_NEVER，上级有事务则异常，无则非事务执行；

四 Spring

1 aop面向切面

说明：在流程中有多处相同的业务逻辑，可以封装方法进行调用而非每处都写一遍逻辑，但每处都写调用也较麻烦，可通过代理对象在指定流程位置执行特定方法。

Spring实现：使用CGLIB动态代理，代理工厂生成传入类的子类、设置子类的回调函数（为代理类本身）、设置类加载器，在调用代理对象时就会被拦截，分别在目标方法执行前、抛异常、执行后调用相应方法，这些方法的方法体可自定义内容以实现相应效果。例如拦截器。由于使用继承实现，不能处理private、static、final修饰的方法和类。

public class CglibMethodInterceptor implements MethodInterceptor {
   /**
    * 用于生成 Cglib 动态代理类工具方法
    * @param target 目标类对象
    * @return
    */
   public Object CglibProxyGeneratory(Class target) {
       // 创建加强器，用来创建动态代理类
       Enhancer enhancer = new Enhancer();
       //设置父类（目标类）
       enhancer.setSuperclass(target);
       //设置方法拦截器回调，对代理类所有方法的调用都会调用CallBack的intercept()
       enhancer.setCallback(this);
       return enhancer.create();
   }
    /**
    * 功能主要是在调用业务类方法之前 之后添加统计时间的方法逻辑.
    * intercept 因为  具有 MethodProxy proxy 参数的原因 不再需要代理类的引用对象了,直接通过proxy 对象访问被代理对象的方法(这种方式更快)。
    * 当然 也可以通过反射机制，通过 method 引用实例    Object result = method.invoke(target, args); 形式反射调用被代理类方法，
    * target 实例代表被代理类对象引用, 初始化 CglibMethodInterceptor 时候被赋值 。但是Cglib不推荐使用这种方式
    * @param obj    代表Cglib 生成的动态代理类 对象本身
    * @param method 代理类中被拦截的接口方法 Method 实例
    * @param args   接口方法参数
    * @param proxy  用于调用父类真正的业务类方法。可以直接调用被代理类接口方法
    * @return
    * @throws Throwable
    */
   @Override
   public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
       before();
       try{
           Object result = proxy.invokeSuper(obj, args);
           //Object result = method.invoke(target, args);
           after();
       }catch(Exception e){
           exception(e);
       }finally{
           fin();
       }
       return result;
   }
   
   //自定义拦截位置和方法，类似生命周期
   private void before(){}
   private void after(){}
   private void exception(Exception e){}
   private void fin(){}
}

...
//使用
Xx x = (Xx)new CglibMethodInterceptor(Xx.class);
x.xxx();

jdk动态代理则使用Proxy.newProxyInstance(类加载器,目标类的接口,handle(自定义方法))创建代理对象，由于靠接口实现，目标类必须继承一个接口。

Spring拦截器独立存在，由SpringIoc管理，通过返回真假决定是否继续流向后续；过滤器由容器调用管理，需调用过滤链对象流向后续流程。

Spring拦截器：继承WebMvcConfigurerAdapter配置类，重写其中的拦截器配置，设置拦截请求；编写拦截器内容并注册。

//配置拦截器
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
     /*
     * 拦截器配置*/
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(new LoginInterceptor()).addPathPatterns("/**");
 }


//拦截器注册
public class LoginInterceptor extends HandlerInterceptorAdapter {
      @Override
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
         //执行内容
         return true;
     }
 }

Spring过滤器：方法1继承Filter接口实现生命周期、注解WebFilter(依照filtername排序)，在入口注解ServletCompomentScan。方法2继承Filter接口实现生命周期，建立配置类注解Configuration，其中每个方法注册过滤器实例并设置顺序如下。

@Configuration
public class FConfig {

    @Bean
    public FilterRegistrationBean r1(){
        FilterRegistrationBean f = new FilterRegistrationBean();//注册方法
        Fi f1 = new Fi();//过滤器实例
        f.setFilter(f1);//设置过滤器
        f.addUrlPatterns("/*");//拦截请求
        f.addServletNames("f1");//名字
        f.setOrder(2);//顺序 越小越优先
        return f;
    }
    @Bean
    public FilterRegistrationBean r2(){
        FilterRegistrationBean f = new FilterRegistrationBean();
        Fi2 f1 = new Fi2();
        f.setFilter(f1);
        f.addUrlPatterns("/*");
        f.addServletNames("f2");
        f.setOrder(1);
        return f;
    }
}

具体的，Spring注入实例时，若未配置切面则生成bean，若配置了切面且有接口则jkd动态代理，否则cglib动态代理。参考：spring 依赖注入时，什么时候会创建代理类

2 Spring具体流程

前置控制器接受request请求；前置控制器根据web.xml或注解匹配控制层；请求由过滤器、拦截器处理；请求由控制层处理，返回模型视图对象；视图解析器返回视图模板；渲染视图，填充模型，得到最终response相应内容，返回。

五 设计模式

1 单例

构造方法为private，只提供一个实例。

饿汉：静态创建实例、静态方法返回实例。应用启动即会一直占用资源。

懒汉：获取实例方法中同步，判断为空再new实例。每次获取实例都会同步，对并发有影响。

获取实例方法中先判断实例为空，空则加锁new实例。

内部类、枚举

2 工厂

静态工厂：工厂类返回各个产品的新建实例

多方法工厂：工厂类中各个方法返回各个产品的实例

普通工厂：工厂类也抽象化，工厂子类返回对应产品的实例。感觉和抽象工厂一个意思，可以再找找资料

3 代理

原来直接调用方法，现在调用一个类，这个类再调用原方法，此类为代理类。如jdk动态代理，实现同一接口，实现中调用原实现类；cglib动态代理，创建子类来代理。

4 观察者

目标类提供动作，目标子类实现具体行为。观察类提供观察动作，观察子类实现自己的响应行为。利用提供的监控类，当目标子类发生变化时，观察子类被监控调用进行响应。

5 模板

父类定义动作，子类实现行为，各个子类遵循相同动作模板，可通过 父类 a = new 子类();获得指定实例。

6 外观

业务层调用业务层方法，若调本类会失去spring的机制支持（如事务），因为本类调用不会被aop等外观模式拦截器拦截。新增一层外观层可解决。