面试题中级

1.mongodb

      mongodb只能存放内网、存放在公网2018年有被攻击的案例，大部分公司并未开启权限所以很危险。
      mongodb是一款NOSQL非关系型数据库。
      Nosql数据库的优缺点
      优点：快速的读写、低廉的成本、灵活的数据模型
      缺点：不提供对sql的支持 支持的特性不搞 现有的产品不够成熟
      Mongodb面向集合存储
      模式自由 
      支持动态查询 
      支持完全索引，包含内部对象 
      支持复制和故障恢复 
      使用高效的二进制数据存储，包括大型对象 
      文件存储格式为BSON(一种JSON的扩展)
      文档(document)是MongoDB中数据的基本单元，非常类似于关系型数据库系统中的行(但是比行要复杂的多)。
      集合(collection)就是一组文档，如果说MongoDB中的文档类似于关系型数据库中的行，那么集合就如同表。
      MongoDB的单个计算机可以容纳多个独立的数据库，每一个数据库都有自己的集合和权限。
      MongoDB自带简洁但功能强大的JavaScript shell，这个工具对于管理MongoDB实例和操作数据作用非常大。
      每一个文档都有一个特殊的键”_id”,它在文档所处的集合中是唯一的，相当于关系数据库中的表的主键。

2.Spring IOC AOP 执行流程步骤（简略）

          方便解耦，简化开发 （高内聚低耦合） 
              Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理 
              spring工厂是用于生成bean
          AOP编程的支持 
              Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
          声明式事务的支持 
              只需要通过配置就可以完成对事务的管理，而无需手动编程
          方便程序的测试 
              Spring对Junit4支持，可以通过注解方便的测试Spring程序
          方便集成各种优秀框架 
              Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
          降低JavaEE API的使用难度 
              Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
Springioc
1.容器初始化
    1、Resource定位：
    2、从Resource中解析和载入BeanDefinition
    3、BeanDefinition在IOC容器的注册
2.IOC容器依赖注入
   1、getBean第一次调用lazy-init的bean
   2、lazy-init==false初始化(只对singleton，也是默认方式)

SpringAop
    1、初始化Advisor链
    2、生成代理类
    3、调用时拦截
  aop底层将采用代理机制进行实现。
  接口 + 实现类 ：spring采用 jdk 的动态代理Proxy。
  实现类：spring 采用 cglib字节码增强。

    自行理解

Spring IOC和Spring AOP的实现原理(源码主线流程) - zedosu - 博客园

3.struts

    Struts2 框架的优点
    了解了这几个主要的优点，会促使你考虑使用Struts2 ：
    POJO表单及POJO操作 - Struts2 去除掉了Struts框架中的Action Forms部分。在Struts2框架下，你可以用任何一POJO来接收表单输入，同样的，你可以把任一POJO视为一个Action类。
    标签支持 - Struts2 改进了标签表单，而新的标签可让开发人员减少代码编写量。
    AJAX支持 - Struts2 被认可接收进Web 2.0技术，并创建了功能非常类似于标准的Struts2 标签的AJAX标签，把AJAX支持整合进其结果中。
    易于整合 - Struts有多种整合方式可使用，现在与其他类型的框架，如Spring、Tiles、SiteMesh之类的，整合更为容易了。
    模板支持 - 支持使用模板生成视图。
    插件支持 - 有大量的插件可用于Struts2，而使用插件可以增强和扩大Struts2 核心行为。
    性能分析 - Struts2 为调试和配置应用程序提供综合的性能分析，此外，Struts也以嵌入调试工具的形式提供集成调试。
    易于修改标签 - 在Struts2 中，可使用Freemarker的模板对标签标记进行调整，而修改标签不需要JSP或是Java知识，基本的HTML、XML和CSS知识就足够了。
    促进减少配置 - Struts2 使用各种设置的默认值促进减少配置，而你不需要再配置什么除非是偏离了Struts2 设定的默认设置。
    视图技术 - Struts2 为多种视图选项（JSP、Freemarker、Velocity、XSLT等）提供支持。
    以上是使Struts2 成为准企业框架的十大优点。
    Struts2 框架的缺点
    尽管Struts2 有一大列的优点，但我们还是要提到关于它的一些仍需不断改进的缺点：
    更大的学习曲线 - 使用Struts MVC，你必须要熟悉JSP、Servlet APIs标准以及一个大型、复杂的框架。
    文档缺乏 - 相比于Servlet和JSP APIs标准，Struts的在线资源较少，许多初学者会发现Apache在线文档混乱并缺乏整理。
    不够透明 - 相比于使用正常的基于Java的Web应用程序，使用Struts的应用程序有许多是进行在后台，这使得框架不易于理解。
    最后说明一点，一个好的框架应该提供各种类型的应用程序都可以使用的通用行为，Struts2 是最好的Web框架之一，并频繁用于RIA（Rich Internet Applications）的发展。

4.mybatis

1.#{}和${}的区别是什么
      ${}是Properties文件中的变量占位符，它可以用于标签属性值和sql内部，属于静态文本替换，比如${driver}会被静态替换为com.mysql.jdbc.Driver。#{}是sql的参数占位符，Mybatis会将sql中的#{}替换为?号，在sql执行前会使用PreparedStatement的参数设置方法，按序给sql的?号占位符设置参数值，比如ps.setInt(0, parameterValue)，#{item.name}的取值方式为使用反射从参数对象中获取item对象的name属性值，相当于param.getItem().getName()。
      MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
  2.Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？
  3.<resultMap>、<parameterMap>、<sql>、<include>、<selectKey>，加上动态sql的9个标签，trim|where|set|foreach|if|choose|when|otherwise|bind等，其中<sql>为sql片段标签，通过<include>标签引入sql片段，<selectKey>为不支持自增的主键生成策略标签。
  4.Mybatis是如何进行分页的？分页插件的原理是什么？
  5.Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页，可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。
6.Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？
不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；毕竟namespace不是必须的，只是最佳实践而已。
原因就是namespace+id是作为Map<String, MappedStatement>的key使用的，如果没有namespace，就剩下id，那么，id重复会导致数据互相覆盖。有了namespace，自然id就可以重复，namespace不同，namespace+id自然也就不同。

7.oracle
Oracle面试题(基础篇) - long77 - 博客园

8.maven maven 多模块
[maven] Maven面试宝典 - wfh6732的博客 - CSDN博客

1. docker是容器技术，你可以把他理解成为一种轻量形的虚拟机。docker的启    动时间是毫秒级，普通虚拟机的启   动时间是秒级 或者是分钟级 
   docker为什么在业务上比普通虚拟机更火，因为他的交付快，
   不管客户是什么linux的分支，只要几行命令，
   就可以将开发环境快速迁移至客户机器上
   举个很简单的列子 
   我们在一台新电脑上安装java环境
   在以前我们需要上传jre或者jdk的安装包，我们需要解压 安装 配置环境 
   特别是配置环境对于新用户来说极其不友好，因为一旦配置错误，就会导致系统进不去 
   但是有了docker之后，
   几行命令就可以安装好你想要的java环境 
   而且还比虚拟机更少的占用资源
   docker容器太多了 管理起来不方便所以有了k8s
   

10.maven多模块构建步骤

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven- 
4.0.0.xsd">
         <modelVersion>4.0.0</modelVersion>
           <!--父模块的 groupId、artifactId、version，子模块可以通过parent继承父模块，使用的就是这里定义 
             的value-->
   <groupId>com.liangyt</groupId>
   <artifactId>maven-multi-module</artifactId>
   <version>1.0-SNAPSHOT</version>

   <!--根pom必须要有-->
   <packaging>pom</packaging>
   <!--子模块-->
   <modules>
       <module>service</module>
       <module>provide</module>
       <module>consumer</module>
   </modules>

   <properties>
       <java-version>1.8</java-version>
       <service-version>1.0-SNAPSHOT</service-version>
       <spring-boot-version>1.5.4.RELEASE</spring-boot-version>
   </properties>

   <!--
       使用dependencyManagement的话，则子模块不会自动继承父POM依赖；
       需要子模块显示定义需要的依赖，如果不写 version 则使用父POM定义的version,如果子模块的依赖写了version则使用子模块的。
   -->
   <dependencyManagement>
       <dependencies>
           <!--该依赖里面其实还包含了很多其它的依赖，这里只是为了示范，生产环境可以细化，只添加需要的依赖-->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
               <version>${spring-boot-version}</version>
           </dependency>
           <!--定义子模块包，其他子模块可以引用-->
           <dependency>
               <groupId>com.liangyt</groupId>
               <artifactId>service</artifactId>
               <version>${service-version}</version>
           </dependency>
       </dependencies>
   </dependencyManagement>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <configuration>
                   <fork>true</fork>
               </configuration>
           </plugin>
           <plugin>
               <artifactId>maven-compiler-plugin</artifactId>
               <configuration>
                   <source>${java-version}</source>
                   <target>${java-version}</target>
               </configuration>
           </plugin>
       </plugins>
   </build>
</project>
service
  <?xml version="1.0" encoding="UTF-8"?>
      <project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!--继承的父模块-->
      <parent>
       <artifactId>maven-multi-module</artifactId>
            <groupId>com.liangyt</groupId>
       <version>1.0-SNAPSHOT</version>
      </parent>

      <modelVersion>4.0.0</modelVersion>

   <!--一般跟父模块下的模块名一致，也是其它模块引用的名称-->
   <artifactId>service</artifactId>
   <!--
       发版的版本号,如果重新发布了新的版本，则父模块添加的该依赖需要新的版本的话还需要相应的修改一下才能引用新的发布包
   -->
   <version>1.0-SNAPSHOT</version>

   <packaging>jar</packaging>

   <!--
       需要哪个依赖就添加哪个依赖：
       如果父模块里面有该依赖的话，则只要不填写版本则跟父模块版本一样；
       如果写了版本号，则跟父模块没有什么关系；
   -->
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
   </dependencies>
</project>

provide
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <parent>
       <artifactId>maven-multi-module</artifactId>
       <groupId>com.liangyt</groupId>
       <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>

   <artifactId>provide</artifactId>

   <dependencies>
       <!--引用service模块-->
       <dependency>
           <groupId>com.liangyt</groupId>
           <artifactId>service</artifactId>
       </dependency>
   </dependencies>
</project>

12.resuful风格优点

*前后端分离，减少流量
安全问题集中在接口上，由于接受json格式，防止了注入型等安全问题
前端无关化，后端只负责数据处理，前端表现方式可以是任何前端语言（android，ios,html5）
前端和后端人员更加专注于各自开发，只需接口文档便可完成前后端交互，无需过多相互了解
服务器性能优化：由于前端是静态页面，通过nginx便可获取，服务器主要压力放在了接口上*

13.什么是json

      *JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
      JSON 是轻量级的文本数据交换格式
      JSON 独立于语言 *
      JSON 具有自我描述性，更易理解*

14.cxf

  *CXF框架特点
  A、与Spring、Servlet做了无缝对接，cxf框架里面集成了Servlet容器Jetty

  B、支持注解的方式来发布webservice

  C、能够显示一个webservice的服务列表

  D、能够添加拦截器：输入拦截器、
  输出拦截器 ：输入日志信息拦截器、输出日志拦截器、用户权限认证的拦截器*

13.函数和存储过程的区别：

  1、存储过程用户在数据库中完成特定操作或者任务（如插入，删除等），函数用于返回特定的数据。

  2、存储过程声明用procedure，函数用function。

  3、存储过程不需要返回类型，函数必须要返回类型。

  4、存储过程可作为独立的pl-sql执行，函数不能作为独立的plsql执行，必须作为表达式的一部分。

  5、存储过程只能通过out和in/out来返回值，函数除了可以使用out，in/out以外，还可以使用return返回值。

  6、sql语句（DML或SELECT)中不可用调用存储过程，而函数可以。

1. 索引建立规则 ``` 如果有两个或者以上的索引，其中有一个唯一性索引，而其他是非唯一，这种情况下oracle将使用唯一性索引而完全忽略非唯一性索引

2. 至少要包含组合索引的第一列（即如果索引建立在多个列上，只有它的第一个列被where子句引用时，优化器才会使用该索引）

3. 小表不要建立索引

4. 对于基数大的列适合建立B树索引，对于基数小的列适合简历位图索引

5. 列中有很多空值，但经常查询该列上非空记录时应该建立索引

6. 经常进行连接查询的列应该创建索引

7. 使用create index时要将最常查询的列放在最前面

8. LONG（可变长字符串数据，最长2G）和LONG RAW（可变长二进制数据，最长2G）列不能创建索引

9.限制表中索引的数量（创建索引耗费时间，并且随数据量的增大而增大；索引会占用物理空间；当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，降低了数据的维护速度） ```