1、拦截机制的不同

Struts2 是类级别的拦截，每次请求就会创建一个 Action，和 Spring 整合时 Struts2 的 ActionBean 注入作用域是原型模式 prototype，然后通过 setter，getter 吧 request 数据注入到属性。Struts2 中，一个 Action 对应一个 request，response 上下文，在接收参数时，可以通过属性接收，这说明属性参数是让多个方法共享的。Struts2 中 Action 的一个方法可以对应一个 url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了，只能设计为多例。

SpringMVC 是方法级别的拦截，一个方法对应一个 Request 上下文，所以方法直接基本上是独立的，独享 request，response 数据。而每个方法同时又何一个 url 对应，参数的传递是直接注入到方法中的，是方法所独有的。处理结果通过 ModeMap 返回给框架。在 Spring 整合时，SpringMVC 的 Controller Bean 默认单例模式 Singleton，所以默认对所有的请求，只会创建一个 Controller，有应为没有共享的属性，所以是线程安全的，如果要改变默认的作用域，需要添加 @Scope 注解修改。

Struts2 有自己的拦截 Interceptor 机制，SpringMVC 这是用的是独立的 Aop 方式，这样导致 Struts2 的配置文件量还是比 SpringMVC 大。

2、底层框架的不同

Struts2 采用 Filter（StrutsPrepareAndExecuteFilter）实现，SpringMVC（DispatcherServlet）则采用 Servlet 实现。Filter 在容器启动之后即初始化；服务停止以后坠毁，晚于 Servlet。Servlet 在是在调用时初始化，先于 Filter 调用，服务停止后销毁。

3、性能方面

Struts2 是类级别的拦截，每次请求对应实例一个新的 Action，需要加载所有的属性值注入，SpringMVC 实现了零配置，由于 SpringMVC 基于方法的拦截，有加载一次单例模式 bean 注入。所以，SpringMVC 开发效率和性能高于 Struts2。

4、配置方面

spring MVC 和 Spring 是无缝的。从这个项目的管理和安全上也比 Struts2 高。

@Required 注解应用于 bean 属性的 setter 方法，它表明影响的 bean 属性在配置时必须放在 XML 配置文件中。

十九、请举例说明 @Qualifier 注解？
如果在 xml 中定义了一种类型的多个 bean，同时在 java 注解中又想把其中一个 bean 对象作为属性，那么此时可以使用 @Qualifier 加 @Autowired 来达到这一目的，若不加 @Qualifier 这个注解，在运行时会出现 “No qualifying bean of type [com.tutorialspoint.Student] is defined: expected single matching bean but found 2: student1,student2” 这个异常。

Spring 常用注解（绝对经典）

通过了解，现在最普遍的权限管理模型就是 RBAC（Role-Based Access Control）。

1、权限控制分类

菜单功能
url 控制（控制访问不同的控制器）
2、RBAC 的优缺点

（1）优点

简化了用户和权限的关系
易扩展、易维护

（2）缺点

RBAC 模型没有提供操作顺序的控制机制，这一缺陷使得 RBAC 模型很难适应哪些对操作次序有严格要求的系统。

3、RBAC 支持的安全原则

（1）最小权限原则

RBAC 可以将角色配置成其完成任务所需的最小权限集合。

（2）责任分离原则

可以通过调用相互独立互斥的角色来共同完成敏感的任务，例如要求一个记账员和财务管理员共同参与统一过账操作。

（3）数据抽象原则

可以通过权限的抽象来体现，例如财务操作用借款、存款等抽象权限，而不是使用典型的读写权限。

4、远古时代的权限控制

当时还没有 RBAC，也没有这个概念，就是一堆程序员在那鼓捣，觉得登录这块该做点什么。

1、新建一个用户，对这个用户进行赋予权限。

2、但是一旦用户多了，权限复杂了，这工作量也是蛮大的。

5、RBAC

RBAC 1.0

直接上图，一目了然，当程序不是很复杂的时候，RBAC 就是这样设计的，我们公司的权限验证模块就是这样设计的。

简简单单，五张表，解

RBAC 2.0

基于 RBAC 1.0 模型的基础上，进行了角色的访问控制

RBAC2 中的一个基本限制是互斥角色的限制，互斥角色是指各自权限可以互相制约的两个角色。对于这类角色一个用户在某一次活动中只能被分配其中的一个角色，不能同时获得两个角色的使用权。

该模型有以下几种约束

• 互斥角色 ：同一用户只能分配到一组互斥角色集合中至多一个角色，支持责任分离的原则。互斥角色是指各自权限互相制约的两个角色。对于这类角色一个用户在某一次活动中只能被分配其中的一个角色，不能同时获得两个角色的使用权。常举的例子：在审计活动中，一个角色不能同时被指派给会计角色和审计员角色。
• 基数约束 ：一个角色被分配的用户数量受限；一个用户可拥有的角色数目受限；同样一个角色对应的访问权限数目也应受限，以控制高级权限在系统中的分配。
• 先决条件角色 ：可以分配角色给用户仅当该用户已经是另一角色的成员；对应的可以分配访问权限给角色，仅当该角色已经拥有另一种访问权限。指要想获得较高的权限，要首先拥有低一级的权限。
• 运行时互斥 ：例如，允许一个用户具有两个角色的成员资格，但在运行中不可同时激活这两个角色。

6、rbac 的实现理论分析

进入登录页面；
拿到通过 post 传过来的用户名和密码；
使用 orm 进行过滤查找；
如果能找到值，则说明登录成功：登录成功后调用 rbac 初始化函数，初始化函数的主要功能是获取用户的权限和菜单保存到 session 中，并跳转客户列表页面；如果失败，页面进行友好提示；

7、url 权限控制关键代码

1、Spring MVC 如何匹配请求路径

@RequestMapping 是用来映射请求的，比如 get 请求、post 请求、或者 REST 风格与非 REST 风格的。该注解可以用在类上或方法上，如果用在类上，表示是该类中所有方法的父路径。

@RequestMapping("/springmvc")
@Controller
public class SpringMVCTest {@RequestMapping("/testRequestMapping")public String testRequestMapping(){System.out.println("testRequestMapping");return SUCCESS;}
}

在类上还添加了一个 @Controller 注解，该注解在 SpringMVC 中负责处理由 DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个 model，然后再把该 model 返回给对应的 view 进行展示。

我们可以通过 “springmvc/testRequestMapping” 这个路径来定位到 testRequestMapping 这个方法，然后执行方法内的方法体。

RequestMapping 可以实现模糊匹配路径，比如：

1. ？表示一个字符；
2. • 表示任意字符；
3. ** 匹配多层路径；

/springmvc/**/testRequestMapping 就可以匹配 / springmvc/stu/getStudentInfo/testRequestMapping 这样的路径了。

2、SpringMVC 如何获取请求的参数

（1）@PathVariable

该注解用来映射请求 URL 中绑定的占位符。通过 @PathVariable 可以将 URL 中占位符的参数绑定到 controller 处理方法的入参中。

@RequestMapping("/testPathVariable/{id}")
public String testPathVariable(@PathVariable(value="id") Integer id){System.out.println("testPathVariable:" + id);return SUCCESS;
}

在 index.jsp 中我们添加一条连接，用来触发一个请求：

<a href="springmvc/testPathVariable/1">testPathVariable</a>

（2） @RequestParam

该注解也是用来获取请求参数的，那么该注解和 @PathVariable 有什么不同呢？

@RequestMapping(value="/testRequestParam")
public String testRequestParam(@RequestParam(value="username") String username, @RequestParam(value="age", required=false, defaultValue="0") int age){System.out.println("testRequestParam" + " username:" + username + " age:" +age);return SUCCESS;
}

在 index.jsp 添加超链接标签

<a href="springmvc/testRequestParam?user>testRequestParam</a>

3、REST 风格的请求

在 SpringMVC 中业务最多的应该是 CRUD 了

@RequestMapping(value="/testRest/{id}", method=RequestMethod.PUT)
public String testRestPut(@PathVariable(value="id") Integer id){System.out.println("test put:" + id);return SUCCESS;
}@RequestMapping(value="/testRest/{id}", method=RequestMethod.DELETE)
public String testRestDelete(@PathVariable(value="id") Integer id){System.out.println("test delete:" + id);return SUCCESS;
}@RequestMapping(value="/testRest", method=RequestMethod.POST)
public String testRest(){System.out.println("test post");return SUCCESS;
}@RequestMapping(value="/testRest/{id}", method=RequestMethod.GET)
public String testRest(@PathVariable(value="id") Integer id){System.out.println("test get:" + id);return SUCCESS;
}

1、通过 JavaScript 屏蔽提交按钮（不推荐）

2、给数据库增加唯一键约束（简单粗暴）

3、利用 Session 防止表单重复提交（推荐）

4、使用 AOP 自定义切入实现

1、简单工厂模式

简单工厂模式的本质就是一个工厂类根据传入的参数，动态的决定实例化哪个类。

Spring 中的 BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得 bean 对象。

2、工厂方法模式

应用程序将对象的创建及初始化职责交给工厂对象，工厂 Bean。

定义工厂方法，然后通过 config.xml 配置文件，将其纳入 Spring 容器来管理，需要通过 factory-method 指定静态方法名称。

3、单例模式

Spring 用的是双重判断加锁的单例模式，通过 getSingleton 方法从 singletonObjects 中获取 bean。

     /*** Return the (raw) singleton object registered under the given name.* <p>Checks already instantiated singletons and also allows for an early* reference to a currently created singleton (resolving a circular reference).* @param beanName the name of the bean to look for* @param allowEarlyReference whether early references should be created or not* @return the registered singleton object, or {@code null} if none found*/protected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return (singletonObject != NULL_OBJECT ? singletonObject : null);}

4、代理模式

Spring 的 AOP 中，使用的 Advice（通知）来增强被代理类的功能。Spring 实现 AOP 功能的原理就是代理模式（① JDK 动态代理，② CGLIB 字节码生成技术代理。）对类进行方法级别的切面增强。

5、装饰器模式

装饰器模式：动态的给一个对象添加一些额外的功能。

Spring 的 ApplicationContext 中配置所有的 DataSource。这些 DataSource 可能是不同的数据库，然后 SessionFactory 根据用户的每次请求，将 DataSource 设置成不同的数据源，以达到切换数据源的目的。

在 Spring 中有两种表现：

一种是类名中含有 Wrapper，另一种是类名中含有 Decorator。

6、观察者模式

定义对象间的一对多的关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

Spring 中观察者模式一般用在 listener 的实现。

7、策略模式

策略模式是行为性模式，调用不同的方法，适应行为的变化 ，强调父类的调用子类的特性 。

getHandler 是 HandlerMapping 接口中的唯一方法，用于根据请求找到匹配的处理器。

8、模板方法模式

Spring JdbcTemplate 的 query 方法总体结构是一个模板方法 + 回调函数，query 方法中调用的 execute() 是一个模板方法，而预期的回调 doInStatement(Statement state) 方法也是一个模板方法。

Spring 注入有四种方式，

1. set 注入；
2. 构造器注入；
3. 基于注解的注入；
4. xml 配置文件注入；

想要注入 java collection，就是注入集合类：

1. list
2. set
3. map
4. props：该标签支持注入键和值都是字符串类型的键值对。

list 和 set 都使用 value 标签；map 使用 entry 标签；props 使用 prop 标签；

1. #{} 带引号，${} 不带引号；
2. #{} 可以防止 SQL 注入；
3. ${} 常用于数据库表名、order by 子句；
4. 一般能用 #{} 就不要使用 ${}；

1、mybatis 是否支持延迟加载？

延迟加载其实就是讲数据加载时机推迟，比如推迟嵌套查询的时机。

延迟加载可以实现先查询主表，按需实时做关联查询，返回关联表结果集，一定程度上提高了效率。

mybatis 仅支持关联对象 association 和关联集合对象 collection 的延迟加载，association 是一对一，collection 是一对多查询，在 mybatis 配置文件中可以配置 lazyloadingEnable=true/false。

2、延迟加载的原理是什么？

使用 CGLIB 为目标对象建立代理对象，当调用目标对象的方法时进入拦截器方法。

比如调用 a.getB().getName()，拦截器方法 invoke() 发现 a.getB() 为 null，会单独发送事先准备好的查询关联 B 对象的 sql 语句，把 B 查询出来然后调用 a.setB(b)，也是 a 的对象的属性 b 就有值了，然后调用 getName()，这就是延迟加载的原理。

一级缓存是 session 级别的缓存，默认开启，当查询一次数据库时，对查询结果进行缓存，如果之后的查询在一级缓存中存在，则无需再访问数据库；

二级缓存是 sessionFactory 级别的缓存，需要配置才会开启。当进行 sql 语句查询时，先查看一级缓存，如果不存在，访问二级缓存，降低数据库访问压力。

1、mybatis 有三种基本的 Executor 执行器：

（1）、SimpleExecutor

每执行一次 update 或 select，就开启一个 Statement 对象，用完立刻关闭 Statement 对象。

（2）、PauseExecutor

执行 update 或 select，以 sql 做为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后，不关闭 Statement 对象，而且放置于 Map 内，供下一次使用。简言之，就是重复使用 Statement 对象。

（3）、BatchExecutor

执行 update，将所有 sql 通过 addBatch() 都添加到批处理中，等待统一执行 executeBatch()，它缓存了多个 Statement 对象，每个 Statement 对象都是 addBatch() 完毕后，等待逐一执行 executeBatch() 批处理。与 JDBC 批处理相同。

2、作用范围：

Executor 的这些特点，都严格限制在 SqlSession 生命周期范围内。

3、Mybatis 中如何指定使用哪一种 Executor 执行器？

在 mybatis 的配置文件中，可以指定默认的 ExecutorType 执行器类型，也可以手动给 DefaultSqlSessionFactory 的创建 SqlSession 的方法传递 ExecutorType 类型参数。

1、两者最大的区别

针对简单逻辑，都有对应的代码生成工具，可以生成简单基本的 dao 层方法；

针对高级查询，mybatis 要手动编写 sql 语句和 resultMap，而 hibernate 有良好的映射机制；

2、开发难度对比

hibernate > mybatis

3、日志统计

hibernate 有自己的日志统计功能，而 mybatis 需要借助 log4j 来记录日志。

4、数据库扩展比较

hibernate > mybatis

5、缓存机制比较

因为 hibernate 对查询对象有良好的管理机制，用户无需关心 sql，所以使用二级缓存如果出现脏数据，系统会报错。

而 mybatis，如果不能获取最新数据，应该避免缓存的使用，脏数据的出现会给系统的正常运行带来很大的隐患。

6、如何选择

1. mybatis 需要编写 sql 和映射规则，工作量大于 hibernate；
2. mybatis 支持的工具也有限，不能像 hibernate 那样有许多插件可以帮助生成映射代码和关联关系；
3. 对于性能要求不太苛刻的系统，比如管理系统、ERP 等推荐 hibernate；
4. 对于性能要求高、响应快、灵活的系统，比如电商系统，推荐使用 mybatis；

myBatis 查询多个 id（我居然回答用对象来传递…）

Page<UserPoJo>  getUserListByIds(@Param("ids") List<Integer> ids);

<!--根据id列表批量查询user-->
<select id="getUserListByIds" resultType="com.guor.UserPoJo">select * from studentwhere id in<foreach collection="ids" item="userid" open="(" close=")" separator=",">#{userid}</foreach>
</select>

1、一级缓存：指的是 mybatis 中 sqlSession 对象的缓存，当我们执行查询以后，查询的结果会同时存入 sqlSession 中，再次查询的时候，先去 sqlSession 中查询，有的话直接拿出，当 sqlSession 消失时，mybatis 的一级缓存也就消失了，当调用 sqlSession 的修改、添加、删除、commit()、close() 等方法时，会清空一级缓存。

2、二级缓存：指的是 mybatis 中的 sqlSessionFactory 对象的缓存，由同一个 sqlSessionFactory 对象创建的 sqlSession 共享其缓存，但是其中缓存的是数据而不是对象。当命中二级缓存时，通过存储的数据构造成对象返回。查询数据的时候，查询的流程是二级缓存 > 一级缓存 > 数据库。

3、如果开启了二级缓存，sqlSession 进行 close() 后，才会把 sqlSession 一级缓存中的数据添加到二级缓存中，为了将缓存数据取出执行反序列化，还需要将要缓存的 pojo 实现 Serializable 接口，因为二级缓存数据存储介质多种多样，不一定只存在内存中，也可能存在硬盘中。

4、mybatis 框架主要是围绕 sqlSessionFactory 进行的，具体的步骤：

1. 定义一个 configuration 对象，其中包含数据源、事务、mapper 文件资源以及影响数据库行为属性设置 settings。
2. 通过配置对象，则可以创建一个 sqlSessionFactoryBuilder 对象。
3. 通过 sqlSessionFactoryBuilder 获得 sqlSessionFactory 实例。
4. 通过 sqlSessionFactory 实例创建 qlSession 实例，通过 sqlSession 对数据库进行操作。

5、代码实例

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
"http://mybatis.org/dtd/mybatis-3-config.dtd">  <configuration>   <!-- 加载类路径下的属性文件 -->  <properties resource="db.properties"/>  <!-- 设置类型别名 -->  <typeAliases>  <typeAlias type="cn.itcast.javaee.mybatis.app04.Student" alias="student"/>  </typeAliases>  <!-- 设置一个默认的连接环境信息 -->  <environments default="mysql_developer">  <!-- 连接环境信息，取一个任意唯一的名字 -->  <environment id="mysql_developer">  <!-- mybatis使用jdbc事务管理方式 -->  <transactionManager type="jdbc"/>  <!-- mybatis使用连接池方式来获取连接 -->  <dataSource type="pooled">  <!-- 配置与数据库交互的4个必要属性 -->  <property ${mysql.driver}"/>  <property ${mysql.url}"/>  <property ${mysql.username}"/>  <property ${mysql.password}"/>  </dataSource>  </environment>  <!-- 连接环境信息，取一个任意唯一的名字 -->  <environment id="oracle_developer">  <!-- mybatis使用jdbc事务管理方式 -->  <transactionManager type="jdbc"/>  <!-- mybatis使用连接池方式来获取连接 -->  <dataSource type="pooled">  <!-- 配置与数据库交互的4个必要属性 -->  <property ${oracle.driver}"/>  <property ${oracle.url}"/>  <property ${oracle.username}"/>  <property ${oracle.password}"/>  </dataSource>  </environment>  </environments>  <!-- 加载映射文件-->  <mappers>  <mapper resource="cn/itcast/javaee/mybatis/app14/StudentMapper.xml"/>  </mappers>  </configuration>  

public class MyBatisTest {public static void main(String[] args) {try {//读取mybatis-config.xml文件InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");//初始化mybatis,创建SqlSessionFactory类的实例SqlSessionFactory sqlSessionFactory =  new SqlSessionFactoryBuilder().build(resourceAsStream);//创建session实例SqlSession session = sqlSessionFactory.openSession();/** 接下来在这里做很多事情,到目前为止,目的已经达到得到了SqlSession对象.通过调用SqlSession里面的方法,* 可以测试MyBatis和Dao层接口方法之间的正确性,当然也可以做别的很多事情,在这里就不列举了*///插入数据User user = new User();user.setC_password("123");user.setC_username("123");user.setC_salt("123");//第一个参数为方法的完全限定名:位置信息+映射文件当中的idsession.insert("com.cn.dao.UserMapping.insertUserInformation", user);//提交事务session.commit();//关闭sessionsession.close();} catch (IOException e) {e.printStackTrace();}}
}

注意：但凡是 sql 注入漏洞的程序，都是因为程序要接受来自客户端用户输入的变量或 URL 传递的参数，并且这个变量或参数是组成 sql 语句的一部分，对于用户输入的内容或传递的参数，我们应该要时刻保持警惕，这是安全领域里的【外部数据不可信任】的原则，纵观 web 安全领域的各种攻击方式，大多数都是因为开发者违反了这个原则而导致的，所以自然能想到，就是变量的检测、过滤、验证下手，确保变量是开发者所预想的。

1、检查变量数据类型和格式

数据类型检查，sql 执行前，要进行数据类型检查，如果是邮箱，参数就必须是邮箱的格式，如果是日期，就必须是日期格式；

只要是有固定格式的变量，在 SQL 语句执行前，应该严格按照固定格式去检查，确保变量是我们预想的格式，这样很大程度上可以避免 SQL 注入攻击。

如果上述例子中 id 是 int 型的，效果会怎样呢？无法注入，因为输入注入参数会失败。比如上述中的 name 字段，我们应该在用户注册的时候，就确定一个用户名规则，比如 5-20 个字符，只能由大小写字母、数字以及汉字组成，不包含特殊字符。此时我们应该有一个函数来完成统一的用户名检查。不过，仍然有很多场景并不能用到这个方法，比如写博客，评论系统，弹幕系统，必须允许用户可以提交任意形式的字符才行，否则用户体验感太差了。

2、过滤特殊符号

3、绑定变量，使用预编译语句

spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true

1、导航对象图查询：根据已加载的对象，导航到其他对象。

例如，对于已经加载的 Customer 对象，调用它的 getOrders().iterator() 方法就可以导航到所有关联的 Order 对象，假如在关联级别使用了延迟加载检索策略，那么首次执行此方法时，hibernate 会从数据库中加载关联的 Order 对象，否则就从缓存中获得 Order 对象。

2、OID 方式：按照对象的 OID 来检索对象

Session 的 get() 和 load() 方法提供了这种功能，如果在应用程序中先知道了 OID，就可以使用这种方式检索对象。

get() 和 load() 的用法完全一样，都需要两个参数，一个是持久化对象类名 class，一个是行号 OID，返回固定的某一行的数据，但是需要注意的是，当输入的 OID 不存在时，get() 会返回一个空对象，load() 则直接报错。

3、HQL 检索方式：（hibernate query language）

使用面向对象的 HQL 查询语言，session 的 find() 方法用于执行 HQL 查询语句。此外，hibernate 还提供了 query 接口，它是 hibernate 提供的专门的 HQL 查询接口，能够执行各种复杂的 HQL 查询语句。

它具备以下功能：

1. 在查询语句中设定各种查询条件；
2. 支持投影查询，即仅检索出对象的部分属性；
3. 支持分页查询；
4. 支持连接查询；
5. 支持分组查询；
6. 提供内置函数；
7. 能够调用用户自定义的 SQL 函数；
8. 支持子查询；
9. 支持动态绑定参数；

例如：

Query query = session.createQuery(“from UserPo”）；

获得一个 query 对象，注意参数字符串中不是一个 SQL 语句，from 后面的是持久化对象名称；

List list = query.list();

就可以获取数据库中对应表的数据集合。

4、QBC 检索方式：Query By Criteria 的 API 来检索对象

这种 API 封装了基于字符串形式的查询语句，提供了更加面向对象的接口。

例：Criteria criteria = session.createCriteria(UserPo.class);

创建一个 Criteria 对象，参数是所关联的持久化对象，criteria.add(Restrictions.ge(“id”,2)); 将查询条件加入对象中，后面的操作就和 Query 对象一样了。

5、本地 SQL

使用本地数据库的 SQL 查询语句，hibernate 会负责把检索到的 JDBC ResultSet 结果映射为持久化对象图。

可以将 hibernate 的实体类定义为 final，但这种做法不好。

因为 hibernate 会使用代理模式在延迟关联的情况下提高性能，如果你把实体类定义成 final 类之后，因为 Java 不允许对 final 类进行扩展，所以 hibernate 就无法再使用代理了，如此一来就限制了使用可以提升性能的手段。

不过，如果你的持久化类实现了一个接口，而且在该接口中声明了所有定义于实体类中的所有 public 的方法的话，就能避免出现前面所说的不利后果。

hibernate 是面向对象的 ORM，所以一般定义成封装类型，要看数据库中的定义，如果数据库中有对应字段存在 null 值，就要定义 Integer。也可以定义基本类型，在配置文件中写清楚即可。

1、Spring Boot 简介

基于 Spring4.0 设计，不仅继承了 Spring 框架原有的优秀特性，而且还通过简化配置来进一步简化 spring 应用的整个搭建和开发过程。另外 SpringBoot 通过集成大量的框架使得依赖包的版本冲突、引用的不稳定性得到了解决。

2、Spring Boot 有哪些优点？

1. 快速构建项目，可以选一些必要的组件；
2. 对主流框架的无配置集成；
3. 内嵌 Tomcat 容器，项目可独立运行；
4. 删除了繁琐的 xml 配置文件；
5. 极大地提高了开发和部署效率；
6. 提供 starter，简化 maven 配置；

3、SpringBoot 有哪些缺点？

1. 版本迭代速度快，一些模块改动很大；
2. 由于无须配置，报错时很难定位；

监听器也叫 listener，是 servlet 的监听器，可以用于监听 web 应用程序中某些对象的创建、销毁、增加、修改、删除等动作的发生，然后做出相应的响应处理。当范围对象的状态发生变化时，服务器自动调用监听器对象中的方法，常用于系统加载时进行信息初始化，统计在线人数和在线用户，统计网站的访问量。

配置监听器的方法：

通过 @Component 把监听器加入 Spring 容器中管理；
在 application.properties 中添加 context.listener.classes 配置；
在方法上加 @EventListener 注解；

YAML 是 JSON 的一个超集，可以非常方便地将外部配置以层次结构形式存储起来。YAML 可以作为 properties 配置文件的替代。

YAML 使用的注意事项：

1. 在 properties 文件中是以 “.” 进行分割的，在 yml 中是用 “.” 进行分割的；
2. yml 的数据格式和 json 的格式很像，都是 K-V 格式，并且通过 “:” 进行赋值；
3. 每个冒号后面一定要加一个空格；

使用 Spring Data Jpa 可以实现将可分页的传递给存储库方法。

1、使用 @ExceptionHandler 注解处理局部异常 (只能处理当前 controller 中的 ArithmeticException 和 NullPointerException 异常，缺点就是只能处理单个 controller 的异常)

@Controller
public class ExceptionHandlerController {@RequestMapping("/excep")public String exceptionMethod(Model model) throws Exception {String a=null;System.out.println(a.charAt(1));int num = 1/0;model.addAttribute("message", "没有抛出异常");return "index";}@ExceptionHandler(value = {ArithmeticException.class,NullPointerException.class})public String arithmeticExceptionHandle(Model model, Exception e) {model.addAttribute("message", "@ExceptionHandler" + e.getMessage());return "index";}
}

2、使用 @ControllerAdvice + @ExceptionHandler 注解处理全局异常 (value 后面可以填写数组)

@ControllerAdvice
public class ControllerAdviceException {@ExceptionHandler(value = {NullPointerException.class})public String NullPointerExceptionHandler(Model model, Exception e) {model.addAttribute("message", "@ControllerAdvice + @ExceptionHandler :" + e.getMessage());return "index";}
}

3、配置 SimpleMappingExceptionResolver 类处理异常（配置类）

@Configuration
public class SimpleMappingException {@Beanpublic SimpleMappingExceptionResolver getSimpleMappingExceptionResolver(){SimpleMappingExceptionResolver resolver = new SimpleMappingExceptionResolver();Properties mappings = new Properties();//第一个参数为异常全限定名，第二个为跳转视图名称mappings.put("java.lang.NullPointerException", "index");mappings.put("java.lang.ArithmeticException", "index");//设置异常与视图映射信息的resolver.setExceptionMappings(mappings);return resolver;}
}

4、实现 HandlerExceptionResolver 接口处理异常

@Configuration
public class HandlerException implements HandlerExceptionResolver {@Overridepublic ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {ModelAndView modelAndView = new ModelAndView();modelAndView.addObject("message", "实现HandlerExceptionResolver接口");//判断不同异常类型，做不同视图跳转if(ex instanceof NullPointerException){modelAndView.setViewName("index");}if(ex instanceof ArithmeticException){modelAndView.setViewName("index");}return modelAndView;}
}

1、概念

单点登录 SSO，说的是在一个多系统共存的环境下，用户在一处登录后，就不用在其他系统中登录，也就是用户的一次登录能得到其他所有系统的信任。

2、单点登录的要点

存储信任；
验证信任；

3、实现单点登录的三种方式

（1）以 cookie 作为凭证

最简单的单点登录实现方式，是使用 cookie 作为媒介，存放用户凭证。

用户登录父应用之后，应用返回一个加密的 cookie，当用户访问子应用的时候，携带上这个 cookie，授权应用解密 cookie 进行校验，校验通过则登录当前用户。

缺点：

cookie 不安全

通过加密可以保证安全性，但如果对方掌握了解密算法就完蛋了。

不能跨域实现免登

（2）通过 JSONP 实现

对于跨域问题，可以使用 JSONP 实现。用户在父应用中登录后，跟 session 匹配的 cookie 会存到客户端中，当用户需要登录子应用的时候，授权应用访问父应用提供的 JSONP 接口，并在请求中带上父应用域名下的 cookie，父应用接收到请求，验证用户的登录状态，返回加密的信息，子应用通过解析返回来的加密信息来验证用户，如果通过验证则登录用户。

缺点：

这种方法虽然能解决跨域问题，但是治标不治本，没有解决 cookie 安全性的问题。

（3）通过页面重定向的方式

最后一种介绍的方式，是通过父应用和子应用来回重定向进行通信，实现信息的安全传递。

父应用提供一个 GET 方式的登录接口 A（此时的父应用接口固定，攻击者无法去伪造），用户通过子应用重定向连接的方式访问这个接口，如果用户还没有登录，则返回一个登录页面，用户输入账号密码进行登录，如果用户已经登录了，则生成加密的 token，并且重定向到子应用提供的验证 token 的接口 B（此时的子应用接口固定，攻击者无法去伪造），通过解密和校验之后，子应用登录当前用户。

缺点：

这种方式较前面的两种方式，是解决了安全性和跨域的问题，但是并没有前面两种方式简单，安全与方便，本来就是矛盾的。

4、使用独立登录系统

一般来说，大型应用会把授权的逻辑和用户信息的相关逻辑独立成一个应用，称为用户中心。用户中心不处理业务逻辑，只是处理用户信息的管理以及授权给第三方应用。第三方应用需要登录的时候，则把用户的登录请求转发给用户中心进行处理，用户处理完毕后返回凭证，第三方应用验证凭证，通过后就登录用户。

5、sso（单点登录）与 OAuth2.0（授权）的区别？

（1）sso（单点登录）

通常处理的是一个公司的不同应用间的访问登录问题，如企业应用有很多子系统，只需登录一个系统，就可以实现不同子系统间的跳转，而避免了登录操作；
通过 cookie、jsonp、重定向来实现；

（2）OAuth2.0（授权）

解决的是服务提供方（如微信）给第三方应用授权的问题，简称微信登录；
是一种具体的协议，只是为用户资源的授权提供了一个安全的、开放的而又简易的标准，OAuth2.0（授权）为客户开发者开发 web 应用，桌面应用程序，移动应用及客厅设备提供特定的授权流程。

Spring Boot 常用注解（绝对经典）

Spring 和 Spring Boot 都支持 maven 和 Gradle 通用打包管理技术。

Spring Boot 相对 Spring 的一些优点：

• 提供嵌入式容器支持；
• 使用命令 java -jar 独立运行 jar；
• 部署时可以灵活指定配置文件；

最近项目是分布式的项目，都是通过分项目打包部署，然后部署在 docker 中运行。

可以使用 druidDataSource 创建 DataSource，然后通过 jdbcTemplate 执行 sql。

通过监听 session 对象的方式来实现在线人数的统计和在线人信息展示，并且让超时的自动销毁。

对 session 对象实现监听，首先必须继承 HttpSessionListener 类，该程序的基本原理就是当浏览器访问页面的时候必定会产生一个 session 对象，当关闭该页面的时候必然会删除 session 对象。所以每当产生一个新的 session 对象就让在线人数 + 1，当删除一个 session 对象就让在线人数 - 1。

还要继承一个 HttpSessionAttributeListener，来实现对其属性的监听。分别实现 attributeAdded 方法，attributeReplace 方法以及 attributeRemove 方法。

sessionCreated// 新建一个会话的时候触发，也可以说是客户端第一次喝服务器交互时触发。

sessionDestroyed// 销毁会话的时候，一般来说只有某个按钮触发进行销毁，或者配置定时销毁。

HttpSessionAttributeListener 有三个方法需要实现

attributeAdded// 在 session 中添加对象时触发此操作 笼统的说就是调用 setAttribute 这个方法时候会触发的
attributeRemoved// 修改、删除 session 中添加对象时触发此操作  笼统的说就是调用 removeAttribute 这个方法时候会触发的
attributeReplaced// 在 Session 属性被重新设置时。

Swagger 是用于生成 RestFul Web 服务的可视化表示工具，它使文档和服务器可视化更新；

当定义好 Swagger 后，可以调用服务端接口，来查看接口的返回值，验证返回数据的正确性；

1、列不可再分；

2、每一行数据只做一件事，只与一列相关，主键；

3、每个属性都与主键有直接关系，而不是间接关系；

三大范式只是设计数据库的基本理念，可以建立冗余较小、结构合理的数据库。如果有特殊情结，当然要特殊对待，数据库设计最重要的是看需求和性能，需求 > 性能 > 表结构。

所以不能一味的追求三范式建立数据库。

一般情况下，我们创建的表类型是 InnoDB。

不重启 MySQL，如果新增一条记录，id 是 8；
重启，ID 是 6；因为 InnoDB 表只把自增主键的最大 ID 记录在内存中，如果重启，已删除的最大 ID 会丢失。
如果表类型是 MyISAM，重启之后，最大 ID 也不会丢失，ID 是 8；

InnoDB 必须有主键（建议使用自增主键，不用 UUID，自增主键索引查询效率高）、支持外键、支持事务、支持行级锁。

系统崩溃后，MyISAM 很难恢复；

综合考虑，优先选择 InnoDB，MySQL 默认也是 InnoDB。

//MySQL,,mysql -v
select version();
//Oracle 
select * from v$version;

ACID 是数据库事务执行的四大基本要素，包括原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。

1、原子性

整个事务中的所有操作，要么全部完成，要不全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被 roolback 回滚到事务开始前的状态，就像这个事务从未执行过一样。

2、一致性

事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。

3、隔离性

隔离状态执行事务，使他们好像是系统在给定时间内执行的唯一操作。

如果有两个事务，运行在相同的时间内，执行相同的功能，事务的隔离性确保每一个事务在系统中认为只有自己在使用系统。这种属性称为串行化，为了防止事务操作间的混淆，必须串行化或序列化请求，使得在同一时间仅有一个请求用于同一数据。

4、持久性

一个成功的事务将永久的改变系统的状态。

1. char 的长度是固定的，varchar 的长度的可变的；
2. char 的效率比 varchar 的效率高；
3. char 占用空间比 varchar 大，char 在查询时需要使用 trim；

1、float 和 double 的区别是什么？

（1）内存中占有的字节数不同

单精度浮点数在内存中占有 4 个字节；

双精度浮点数在内存中占有 8 个字节；

（2）有效数字位数不同

单精度浮点数有效数字 8 位；

双精度浮点数有效数字 16 位；

（3）数值取值范围不同

单精度浮点数的表示范围：-3.40E+38~3.40E+38

双精度浮点数的表示范围：-1.79E+308~-1.79E+308

（4）在程序中处理速度不同

一般来说，CPU 处理单精度浮点数的速度比双精度浮点数的速度快

如果不声明，默认小数是 double 类型，如果想用 float，要进行强转；

2、例如

float f = 1.3；会编译报错，正确的写法是 float f = (float)1.3; 或者 float a = 1.3f;（f 或 F 都可以不区分大小写）

3、注意

float 是八位有效数字，第七位会四舍五入；

4、面试题

（1）java 中 3*0.1==0.3 将会返回什么？true 还是 false？

答：返回 false，因为浮点数不能完全精确的表示出来，一般会损失精度；

（2）java 中 float f = 3.4; 是否正确？

答：不正确。因为 3.4 是双精度浮点数，将双精度赋给单精度属于向下转型，会造成精度损失，因此需要强制类型转换 float=（float）3.4; 或者写成 float f = 3.4f;

#不带排序的
SELECT * FROM (
SELECT ROWNUM AS rowno, t.* FROM worker t where ROWNUM <=20) table_alias 
WHERE table_alias.rowno > 10;

#带排序的
SELECT * FROM (
SELECT tt.*, ROWNUM AS rowno FROM (  
SELECT t.* FROM worker t ORDER BY wkid aSC) tt WHERE ROWNUM <= 20) table_alias 
WHERE table_alias.rowno >= 10;

1、主键约束

主键列上没有任何两行具有相同值（即重复值），不允许空（NULL）；

2、唯一性约束

保证一个字段或者一组字段里的数据都与表中其它行的对应数据不同。和主键约束不同，唯一性约束允许为 null，但是只能有一行；

3、唯一性索引

不允许具有索引值相同的行，从而禁止重复的索引和键值；

4、三者的区别

• 约束是用来检查数据的正确性；
• 索引是用来优化查询的；
• 创建唯一性约束会创建一个约束和一个唯一性索引；
• 创建唯一性索引只会创建一个唯一性索引；
• 主键约束和唯一性约束都会创建一个唯一性索引。

1、数据库设计最起码要占用这个项目开发的 40% 以上的时间

2、数据库设计不仅仅停留在页面 demo 的表面

页面内容所需字段，在数据库设计中只是一部分，还有系统运转、模块交互、中转数据、表之间的联系等等所需要的字段，因此数据库设计绝对不是简单的基本数据存储，还有逻辑数据存储。

3、数据库设计完成后，项目 80% 的设计开发都要存在你的脑海中

每个字段的设计都要有他存在的意义，要清楚的知道程序中如何去运用这些字段，多张表的联系在程序中是如何体现的。

4、数据库设计时就要考虑效率和优化问题

数据量大的表示粗粒度的，会冗余一些必要字段，达到用最少的表，最弱的表关系去存储海量的数据。大数据的表要建立索引，方便查询。对于含有计算、数据交互、统计这类需求时，还有考虑是否有必要采用存储过程。

5、添加必要的冗余字段

像创建时间、修改时间、操作用户 IP、备注这些字段，在每张表中最好都有，一些冗余的字段便于日后维护、分析、拓展而添加。

6、设计合理的表关联

若两张表之间的关系复杂，建议采用第三张映射表来关联维护两张表之间的关系，以降低表之间的直接耦合度。

7、设计表时不加主外键等约束关联，系统编码阶段完成后再添加约束性关联

8、选择合适的主键生成策略

数据库的设计难度其实比单纯的技术实现难很多，他充分体现了一个人的全局设计能力和掌控能力，最后说一句，数据库设计，很重要，很复杂。

区分度不高的字段不适合做索引，因为索引页是需要有开销的，需要存储的，不过这类字段可以做联合索引的一部分。

1、查询重复的单个字段（group by）

select 重复字段A, count(*) from 表 group by 重复字段A having count(*) > 1

2、查询重复的多个字段（group by）

select 重复字段A, 重复字段B, count(*) from 表 group by 重复字段A, 重复字段B having count(*) > 1

1、选取适合的字段属性

• 为了获取更好的性能，可以将表中的字段宽度设得尽可能小。
• 尽量把字段设置成 not null
• 执行查询的时候，数据库不用去比较 null 值。
• 对某些省份或者性别字段，将他们定义为 enum 类型，enum 类型被当做数值型数据来处理，而数值型数据被处理起来的速度要比文本类型块很多。

2、使用 join 连接代替子查询

3、使用联合 union 来代替手动创建的临时表

注意：union 用法中，两个 select 语句的字段类型要匹配，而且字段个数要相同。

4、事务

要么都成功，要么都失败。

可以保证数据库中数据的一致性和完整性。事务以 begin 开始，commit 关键字结束。

如果出错，rollback 命令可以将数据库恢复到 begin 开始之前的状态。

事务的另一个重要作用是当多个用户同时使用相同的数据源时，它可以利用锁定数据库的方式为用户提供一种安全的访问方式，这样就可以保证用户的操作不被其他的用户干扰。

5、锁定表

尽管事务是维护数据库完整性的一个非常好的方法，但却因为它的独占性，有时会影响数据库的性能，尤其是在大应用中。

由于在事务执行的过程中，数据库会被锁定，因此其它用户只能暂时等待直到事务结束。

有的时候可以用锁定表的方法来获得更好的性能，

共享锁：其它用户只能看，不能修改

lock table person in share mode；

对于通过 lock table 命令主动添加的锁来说，如果要释放它们，只需发出 rollback 命令即可。

6、使用外键

锁定表的方法可以维护数据的完整性，但是它却不能保证数据的关联性，这个时候可以使用外键。

7、使用索引

索引是提高数据库查询速度的常用方法，尤其是查询语句中包含 max()、min()、order by 这些命令的时候，性能提高更为显著。

一般来说索引应该建在常用于 join、where、order by 的字段上。尽量不要对数据库中含有大量重复的值得字段建立索引。

8、优化的查询语句

在索引的字段上尽量不要使用函数进行操作。

尽量不要使用 like 关键字和通配符，这样做法很简单，但却是以牺牲性能为代价的。

避免在查询中进行自动类型转换，因为类型转换也会使索引失效。

1. b-tree 索引，如果不建立索引的情况下，oracle 就自动给每一列都加一个 B 树索引;
2. normal：普通索引
3. unique：唯一索引
4. bitmap：位图索引，位图索引特定于只有几个枚举值的情况，比如性别字段；
5. 基于函数的索引

1. 内连接, 显示两个表中有联系的所有数据;
2. 左链接, 以左表为参照, 显示所有数据, 右表中没有则以 null 显示
3. 右链接, 以右表为参照显示数据，, 左表中没有则以 null 显示

1、解决异步问题

例如用户注册，发送邮件和短信反馈注册成功，可以使用 RabbitMQ 消息队列，用户无需等待反馈。

2、服务间解耦

订单系统和库存系统，中间加入 RabbitMQ 消息队列，当库存系统出现问题时，订单系统依旧能正常使用，降低服务间耦合度。

3、秒杀系统

利用 RabbitMQ 的最大值，实现秒杀系统。

1、RabbitMQ 有哪些重要的角色？

客户端、RabbitMQ、服务端。

2、有哪些重要的组件？

（1）connectionFactory（连接管理器）

应用程序与 RabbitMQ 之间建立连接的管理器。

（2）Channel（信道）

消息推送使用的信道。

（3）RoutingKey（路由键）

用于把生产者的数据分配到交换机上。

（4）Exchange（交换机）

用于接受和分配消息。

（5）BindKey（绑定键）

用于把交换机的消息绑定到队列上

（6）Queue（队列）

用于存储生产者消息。

vhost 可以理解为 mini 版的 RabbitMQ，其内部均含有独立的交换机、绑定、队列，最重要的是拥有独立的权限系统，可以做到 vhost 范围内的用户控制。从 RabbitMQ 全局考虑，不同的应用可以跑在不同的 vhost 上，作为不同权限隔离的手段。

JVM 包括类加载子系统、堆、方法区、栈、本地方法栈、程序计数器、直接内存、垃圾回收器、执行引擎。

1、类加载子系统

类加载子系统负责加载 class 信息，加载的类信息存放于方法区中。

2、直接内存

直接内存是在 Java 堆外的、直接向系统申请的内存空间。访问直接内存的速度会由于 Java 堆。出于性能的考虑，读写频繁的场合可能会考虑使用直接内存。

3、垃圾回收器

垃圾回收器可以对堆、方法区、直接内存进行回收。

4、执行引擎

执行引擎负责执行虚拟机的字节码，虚拟机会使用即时编译技术将方法编译成机器码后再执行。

运行时数据区包括堆、方法区、栈、本地方法栈、程序计数器。

1、堆

堆解决的是对象实例存储的问题，垃圾回收器管理的主要区域。

2、方法区

方法区可以认为是堆的一部分，用于存储已被虚拟机加载的信息，常量、静态变量、即时编译器编译后的代码。

3、栈

栈解决的是程序运行的问题，栈里面存的是栈帧，栈帧里面存的是局部变量表、操作数栈、动态链接、方法出口等信息。

（1）栈帧

每个方法从调用到执行的过程就是一个栈帧在虚拟机栈中入栈到出栈的过程。

（2）局部变量表

用于保存函数的参数和局部变量。

（3）操作数栈

操作数栈又称操作栈，大多数指令都是从这里弹出数据，执行运算，然后把结果压回操作数栈。

4、本地方法栈

与栈功能相同，本地方法栈执行的是本地方法，一个 Java 调用非 Java 代码的接口。

5、程序计数器（PC 寄存器）

程序计数器中存放的是当前线程所执行的字节码的行数。JVM 工作时就是通过改变这个计数器的值来选取下一个需要执行的字节码指令。